{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepOnet_FF_antideriv.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "machine_shape": "hm"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.experimental.ode import odeint\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply\n",
    "\n",
    "\n",
    "# Define Fourier feature net\n",
    "def FF_MLP(layers, freqs, activation=relu):\n",
    "   # Define input encoding function\n",
    "    def input_encoding(x, w):\n",
    "        out = np.hstack([np.sin(np.dot(x, w)),\n",
    "                         np.cos(np.dot(x, w))])\n",
    "        return out\n",
    "    FF = freqs * random.normal(random.PRNGKey(0), (layers[0], layers[1]//2))\n",
    "    def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[1:-1], layers[2:]))\n",
    "      return params\n",
    "    def apply(params, inputs):\n",
    "        H = input_encoding(inputs, FF)\n",
    "        for W, b in params[:-1]:\n",
    "            outputs = np.dot(H, W) + b\n",
    "            H = activation(outputs)\n",
    "        W, b = params[-1]\n",
    "        outputs = np.dot(H, W) + b\n",
    "        return outputs\n",
    "    return init, apply"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u # input sample\n",
    "        self.y = y # location\n",
    "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):     \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)\n",
    "        # Apply Fourier feature network to the trunk net\n",
    "        self.trunk_init, self.trunk_apply = FF_MLP(trunk_layers, freqs=50, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=5000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "        \n",
    "        # Loggers\n",
    "        self.loss_log = []\n",
    "        self.loss_operator_log = []\n",
    "        self.loss_physics_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, y):\n",
    "        branch_params, trunk_params = params\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return outputs\n",
    "    \n",
    "    # Define ODE/PDE residual\n",
    "    def residual_net(self, params, u, y):\n",
    "        s_y = grad(self.operator_net, argnums = 2)(params, u, y)\n",
    "        return s_y\n",
    "    \n",
    "    # Define operator loss\n",
    "    def loss_operator(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u, y), shape = (N, m), (N,1)\n",
    "        # outputs: s, shape = (N,1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.operator_net, (None, 0, 0))(params, u, y)\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
    "        return loss\n",
    "\n",
    "    # Define physics loss\n",
    "    def loss_physics(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u_r, y_r), shape = (NxQ, m), (NxQ,1)\n",
    "        # outputs: s_r, shape = (NxQ, 1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0))(params, u, y)\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
    "        return loss    \n",
    "    \n",
    "    # Define total loss\n",
    "    def loss(self, params, operator_batch, physics_batch):\n",
    "        loss_operator = self.loss_operator(params, operator_batch)\n",
    "        loss_physics = self.loss_physics(params, physics_batch)\n",
    "        loss = loss_operator + loss_physics\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, operator_batch, physics_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, operator_batch, physics_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, operator_dataset, physics_dataset, nIter = 10000):\n",
    "        # Define the data iterator\n",
    "        operator_data = iter(operator_dataset)\n",
    "        physics_data = iter(physics_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            operator_batch= next(operator_data)\n",
    "            physics_batch = next(physics_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, operator_batch, physics_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, operator_batch, physics_batch)\n",
    "                loss_operator_value = self.loss_operator(params, operator_batch)\n",
    "                loss_physics_value = self.loss_physics(params, physics_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_operator_log.append(loss_operator_value)\n",
    "                self.loss_physics_log.append(loss_physics_value)\n",
    "\n",
    "                # Print losses during training\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_operator' : loss_operator_value, \n",
    "                                  'loss_physics': loss_physics_value})\n",
    "       \n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s_y(self, params, U_star, Y_star):\n",
    "        s_y_pred = vmap(self.residual_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_y_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k6NL6NI7P9Jo"
   },
   "source": [
    "# Length scale of a Gaussian random field (GRF)\n",
    "length_scale = 0.01\n",
    "\n",
    "# Define RBF kernel\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, m=100, P=1):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y_train = random.uniform(key, (P,)).sort() \n",
    "    s_train = odeint(u_fn, 0.0, np.hstack((0.0, y_train)))[1:] # JAX has a bug and always returns s(0), so add a dummy entry to y and return s[1:]\n",
    "\n",
    "    # Tile inputs\n",
    "    u_train = np.tile(u, (P,1))\n",
    "\n",
    "    # training data for the residual\n",
    "    u_r_train = np.tile(u, (m, 1))\n",
    "    y_r_train = x\n",
    "    s_r_train = u\n",
    "\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, m=100, P=100):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y = np.linspace(0, 1, P)\n",
    "    s = odeint(u_fn, 0.0, y)\n",
    "\n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P,1))\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_training_data(key, m, P))\n",
    "    u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(gen_fn)(keys)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P,-1))\n",
    "    y_train = np.float32(y_train.reshape(N * P,-1))\n",
    "    s_train = np.float32(s_train.reshape(N * P,-1))\n",
    "\n",
    "    u_r_train = np.float32(u_r_train.reshape(N * m,-1))\n",
    "    y_r_train = np.float32(y_r_train.reshape(N * m,-1))\n",
    "    s_r_train = np.float32(s_r_train.reshape(N * m,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_test_data(key, m, P))\n",
    "    u, y, s = vmap(gen_fn)(keys)\n",
    "    u = np.float32(u.reshape(N * P,-1))\n",
    "    y = np.float32(y.reshape(N * P,-1))\n",
    "    s = np.float32(s.reshape(N * P,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u, y, s\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, m, P):\n",
    "    # Generate one test sample\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, m, P)\n",
    "    \n",
    "    # Predict the solution and the residual\n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    s_y_pred = model.predict_s_y(params, u_test, y_test)\n",
    "\n",
    "    # Compute relative l2 error\n",
    "    error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "    error_u = np.linalg.norm(u_test[::P_test].flatten()[:,None] - s_y_pred) / np.linalg.norm(u_test[::P_test].flatten()[:,None]) \n",
    "\n",
    "    return error_s, error_u\n"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZQ-HVgaQt0DO"
   },
   "source": [
    "# Training data for  operator loss\n",
    "N_train = 5000\n",
    "m = 200 # number of input sensors\n",
    "P_train = 1 # number of output sensors\n",
    "key_train = random.PRNGKey(0) # use different key for generating training data  and test data\n",
    "u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = generate_training_data(key_train, N_train, m, P_train)\n",
    "\n",
    "y_train = np.zeros((N_train, 1))\n",
    "s_train = np.zeros((N_train, 1))"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 200, 200, 200, 200, 200]\n",
    "trunk_layers =  [1, 200, 200, 200, 200, 200]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "operator_dataset = DataGenerator(u_train, y_train, s_train, N_train)\n",
    "physics_dataset = DataGenerator(u_r_train, y_r_train, s_r_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "gW8Ej5Jvhf0r",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "8db817cf-47b1-48ff-a669-80b3c64ec80d"
   },
   "source": [
    "# Train\n",
    "model.train(operator_dataset, physics_dataset, nIter=300000)"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 300000/300000 [57:30<00:00, 86.94it/s, Loss=2.111522e-05, loss_operator=1.0873125e-09, loss_physics=2.1114132e-05]\n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "hFf9NGzBiDS5",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "9886e5c6-8068-4daa-866c-e982e991eef1"
   },
   "source": [
    "# Compute test error\n",
    "N_test = 1000 # number of input samples \n",
    "P_test = m   # number of sensors \n",
    "key_test = random.PRNGKey(12345) # A different key \n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Compute errors over test dataset\n",
    "error_s, error_u = vmap(compute_error, (0, None, None))(keys_test, m, P_test) \n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('mean of relative L2 error of u: {:.2e}'.format(error_u.mean()))\n",
    "\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))\n",
    "print('std L2 error of u: {:.2e}'.format(error_u.std()))"
   ],
   "execution_count": 10,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 6.35e-03\n",
      "mean of relative L2 error of u: 6.55e-03\n",
      "std of relative L2 error of s: 5.05e-03\n",
      "std L2 error of u: 1.34e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "uhMrQopGN__b",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "outputId": "bd269dc2-2fa9-40a3-fefe-77310b5adce1"
   },
   "source": [
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "# plt.plot(model.loss_log, lw=2)\n",
    "plt.plot(model.loss_operator_log, lw=2, label='operator')\n",
    "plt.plot(model.loss_physics_log, lw=2, label='physics')\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "NicghBbsmLUH"
   },
   "source": [
    "# Generate test data\n",
    "N_test = 1000\n",
    "P_test = m\n",
    "key_test = random.PRNGKey(12345)\n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "u_test, y_test, s_test =  generate_test_data(key_test, N_test, m, m)\n",
    "\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Model predictions\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "s_y_pred = model.predict_s_y(params, u_test, y_test)"
   ],
   "execution_count": 12,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "HnmPiwmALsgF",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 754
    },
    "outputId": "91fe7cf8-35df-4e64-b1a3-ad5c320c2a5a"
   },
   "source": [
    "# Plot for one generated data\n",
    "# idx = onp.random.randint(N_test) # random visualizations\n",
    "idx=0\n",
    "index = np.arange(idx * P_test,(idx + 1) * P_test)\n",
    "\n",
    "# Compute the relative l2 error for one input sample \n",
    "error_u = np.linalg.norm(s_test[index, :] - s_pred[index, :], 2) / np.linalg.norm(s_test[index, :]) \n",
    "error_s = np.linalg.norm(u_test[::P_test][idx].flatten()[:,None] - s_y_pred[index, :]) / np.linalg.norm(u_test[::P_test][idx].flatten()[:,None]) \n",
    "\n",
    "print(\"error_u: {:.3e}\".format(error_u))\n",
    "print(\"error_s: {:.3e}\".format(error_s))\n",
    "\n",
    "# Visualizations\n",
    "# Predicted solution s(y)\n",
    "plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], s_test[index, :], label='Exact s', lw=2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :], '--', label='Predicted s', lw=2)\n",
    "plt.xlabel('y')\n",
    "plt.ylabel('s(y)')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :] - s_test[index, :], '--', lw=2, label='error')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Predicted residual u(x)\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], u_test[::P_test][idx], label='Exact u', lw=2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:], '--', label='Predicted u', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:].flatten() - u_test[::P_test][idx] , '--', label='error', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 15,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "error_u: 1.710e-03\n",
      "error_s: 5.922e-03\n"
     ],
     "name": "stdout"
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAFgCAYAAACmKdhBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3wb5f3H36dteY9sJ3H2hDiBbBLCCmEUCgVSaFllldGWFvpr6aAtDasDKKuU3TJKgJLSAqGsQAiB7JC9h+O9Zcvauuf3x+lkeSZ2NGz5eb9eeUU6nZ77Sr7TPZ/nuxQhBBKJRCKRSCQSiUQiOX4MiTZAIpFIJBKJRCKRSJIFKbAkEolEIpFIJBKJJEpIgSWRSCQSiUQikUgkUUIKLIlEIpFIJBKJRCKJElJgSSQSiUQikUgkEkmUMCXioHl5eaKgoCARh5ZIJBJJgtiwYUO1EKJfou2IBfK+JpFIJH2Pju5rCRFYBQUFrF+/PhGHlkgkEkmCUBTlcKJtiBXyviaRSCR9j47uazJEUCKRSCQSiUQikUiihBRYEolEIpFIJBKJRBIlpMCSSCQSiUQikUgkkiiRkBwsiUQiiTd+v5/i4mI8Hk+iTUl6bDYb+fn5mM3mRJsikUgkkhjQ1+6pXb2vSYElkUj6BMXFxaSnp1NQUICiKIk2J2kRQlBTU0NxcTEjRoxItDkSiUQiiQF96Z7anfuaDBGUSCR9Ao/HQ25ubtLfCBKNoijk5ub2mVVNiUQi6Yv0pXtqd+5rUmBJJJI+Q1+4EfQE5PcskUgkyU9f+q3v6meVAksikUgkEolEIpFIooQUWBKJRBIHjEYjhYWF4X8PPPBA1MbevHkz7733XtTGk0gkEolE0n1kkQuJRCKJAykpKWzevDkmY2/evJn169dz7rnnxmR8iUQikUh6I8FgEKPR2OHz9hBCIITAYOi+H0p6sCQSiSRBOBwOxo0bx+7duwG4/PLLeeaZZwC4+eabOfnkk5k0aRK/+c1vwu9Zt24dc+bMYcqUKcyYMQOHw8Hdd9/N0qVLKSwsZOnSpS2O8eKLL3LbbbeFn59//vl8+umnsf9wEolEIpHEmJdffpkZM2ZQWFjITTfdRDAYJC0tjTvuuIMpU6bw5Zdftnn+0EMPMXnyZCZPnswjjzwCwKFDhxg3bhxXXXUVkydP5siRI8dll/RgSSSSPkfBz9+NybiHHjivw9fcbjeFhYXh53fddReLFy/m8ccf55prruFHP/oRdXV13HDDDQDce++95OTkEAwGOeOMM9iyZQvjx49n8eLFLF26lOnTp9PQ0IDdbueee+5h/fr1PP744zH5XBKJRCKRdEZn99X7LjqBK2YOA+DVNUX8YtnWDvft7D7amp07d7J06VK++OILzGYzt9xyC6+88gpNTU3MnDmTP//5zwAtnm/YsIEXXniBNWvWIIRg5syZnHrqqWRnZ7N3717+/ve/M2vWrGO2oSOkwJJIJEnFzj37OPzP27EtuJ0Fp56ZaHPCdBQieNZZZ/HGG29w66238vXXX4e3v/766zz99NMEAgHKysrYsWMHiqIwaNAgpk+fDkBGRkbc7JdIJBJJ76W03s2lT33JTaeO5KrZBYk2Jyp8/PHHbNiwIXxPdLvd9O/fH6PRyLe+9a3wfpHPV61axUUXXURqaioAF198MZ9//jkXXHABw4cPj4q4AimwJBJJkpHx9lUsEtupXbUXTt3d7j5dWSGLNaqqsnPnTux2O3V1deTn53Pw4EH+9Kc/sW7dOrKzs7nmmmu63VfKZDKhqmr4uexPJZFIJH2PRz7aQ0m9m7vf3h4TgXWs99UrZg4Le7OOFyEEV199Nffff3+L7X/6059a5FnZbLaj5l0BYdEVDWQOlkQiSSqGNG0HIC1Ql2BLjo2HH36YCRMm8Oqrr3Lttdfi9/tpaGggNTWVzMxMKioqWL58OQDjxo2jrKyMdevWAdDY2EggECA9PZ3GxsZ2xy8oKGDz5s2oqsqRI0dYu3Zt3D6bRCKRSHoGAVUk2oSoc8YZZ/Dmm29SWVkJQG1tLYcPH+70PfPmzePf//43LpeLpqYmli1bxrx586Jum/RgSSSSpMHjrMcWenx3/0eJXiH046d1DtaiRYu49tprefbZZ1m7di3p6enMnz+fJUuW8Lvf/Y6pU6cyfvx4hg4dyty5cwGwWCwsXbqUH/zgB7jdblJSUvjoo4847bTTeOCBBygsLAzndunMnTuXESNGMHHiRCZMmMC0adPi/tklEolEklguOSmftzaWMCU/M9GmRI2JEyeyZMkSFi5ciKqqmM1mnnjiiU7fM23aNK655hpmzJgBwPXXX8/UqVM5dOhQVG2TAksikSQNhzZ+xHhgkzqanerQRJvTgmAw2O72nTt3hh8/9NBD4ccvvvhiu/tPnz6dr776qs123avVGkVReOWVV7pgqUQikUiSDatJC1ozGJQEWxJdFi9e3GJREcDpdHb6/Cc/+Qk/+clPWmwrKChg27ZtUbNLhghKJJKkwb1nBQCr1Yk4Pf4EWyORSCQSSc/AEspB8gfVo+wpiQbSgyWRSJKG9wMnsSdQzHzDFvo1PQUsSLRJEolEIpEknK8O1AAwMCMlwZb0DaTAkkgkSYGqCl6ryEcNfJettusZEaxItEkSiUTSZzhQ5WRIdgpW09GrtUniT6M3AMDkIdFr7yGEQFGSK+SwI4ToWpEQGSIokUiSgqJaFw63H3ualsCbprgJBgIJtkoi6Z18sa+asb9czpXPrUm0KZJewKq91Zz+58+46jlZpbSn4gtooYEWU3Sm/jabjZqami4Lj96IEIKamhpsNtvRdw4hPVgSiSQpqDuyk8XGFRgyJuGsSSFNcdPkdJCRlZto0ySSXodBUfAF1fCkTCLpjLc3lwCw5mBtgi2RdITD7QNg2cYSblkw+rjHy8/Pp7i4mKqqquMeqzdgs9nIz88/5v2lwJJIJEmBUvQFD5qfYXVgES4lhTTcuBrrpMCSSLrBhsPaRFlOmCXHQhK2WEo66l1a4ae9lc6j7HlsmM1mRowYEZWxkhEZIiiRSJKCoEPLuQqm5OEyaN3YPY09p9mw0WiksLCQyZMnc+mll+Jyubo91jXXXMObb74JaD08duzY0eG+n376KatXr+7yMQoKCqiuru62jZLeTanDk2gTJL2IIdmycEJPpw9E8vUopMCSSCTJQZMmsETaADy6wHI6EmlRC1JSUti8eTPbtm3DYrHw1FNPtXg90M18sWeffZaJEyd2+Hp3BZakbyMnY5KucPr4/gCcmERNbJMNVV7UcUUKLIlEkhSY3Jq3xZQxkBLrKNarY2kK9syfuHnz5rFv3z4+/fRT5s2bxwUXXMDEiRMJBoP89Kc/Zfr06Zx44on87W9/A7QE29tuu41x48Zx5plnUllZGR5rwYIFrF+/HoD333+fadOmMWXKFM444wwOHTrEU089xcMPP0xhYSGff/45VVVVfOtb32L69OlMnz6dL774AoCamhoWLlzIpEmTuP766ztMXE5LSws/fvPNN7nmmmti9C1JJJLewrgB6Xzw4/k8+Z1piTZF0gFzR+eFH/eFwhSJRuZgSSSSpMDm1QSWLWsgLw26g+U15TyROqHjN/y2k5XW8x+Bk6/VHq9/Ad65vZNxuuYlCwQCLF++nEWLFgGwceNGtm3bxogRI3j66afJzMxk3bp1eL1e5s6dy8KFC9m0aRO7d+9mx44dVFRUMHHiRL73ve+1GLeqqoobbriBlStXMmLECGpra8nJyeH73/8+aWlp3HnnnQBcccUV/PjHP+aUU06hqKiIs88+m507d/K73/2OU045hbvvvpt3332X5557rkufS5JsyAmY5NjxBVSyUsxkpJgTbYqkA66eU8A97+wgqAqCqsBk7Bvl1ROFFFgSiSQpSPNryfhpuUNIq9R+2pxefyJNaoHb7aawsBDQPFjXXXcdq1evZsaMGeFE4Q8++IAtW7aE86scDgd79+5l5cqVXH755RiNRgYPHszpp5/eZvyvvvqK+fPnh8fKyclp146PPvqoRc5WQ0MDTqeTlStX8tZbbwFw3nnnkZ2dHb0PL+l1pFm1a2hojsytkRydxz7Zy7OrDnLXOeO56dRRiTZH0gFmo0JQFfiCKiZjz4zwSBakwJJIJEmBRXUDkNlvCGkHa7Dgx9XUSbWkY/U8nXxtszfrONBzsFqTmpoafiyE4LHHHuPss89usc9777133MfXUVWVr776qkv9PCKJbCrp8chCCIliU1EdG4vq+d7cgpg0+tR75Sw+eWjUx5YkHxWNXgDuX74rrgLL6Q2wel81p47rJxscH4UDVU48fq3tgj8gwJJgg5IcKV8lEkmvJ6gKZnqfYILneXJy+3Fm5YvssV3NhP3PJtq0LnH22Wfz17/+Fb9f87zt2bOHpqYm5s+fz9KlSwkGg5SVlbFixYo27501axYrV67k4MGDANTWah699PR0Ghsbw/stXLiQxx57LPxcF33z58/n1VdfBWD58uXU1bVfgXHAgAHs3LkTVVVZtmxZFD61pDtc9ORqfv/ODj7ZVXn0nbvBsBw7c0blMjTHHpPxJcmF05OYaIEfvLqRG1/awIPLdyfk+L2JH762CYD/3DaXTLsM5Yw1UmBJJJJeT22TD1WAzZ6O2WREsWiFGAy+xqO8s2dx/fXXM3HiRKZNm8bkyZO56aabCAQCXHTRRYwZM4aJEydy1VVXMXv27Dbv7devH08//TQXX3wxU6ZMYfHixQB84xvfYNmyZeEiF48++ijr16/nxBNPZOLEieFqhr/5zW9YuXIlkyZN4q233mLYsGHt2vjAAw9w/vnnM2fOHAYNGhS7L0NyTByp7X65/8645KShXDwtH69fNhqWHJ1gglL2VuzWmty+u7U0MQb0IvRrWXr64oMMEZRIJL2eaqcWntIv3QqAISVD+78HCSyns2244oIFC1iwYEH4ucFg4L777uO+++5rs+/jjz/e7riffvpp+PE555zDOeec0+L1sWPHsmXLlhbbli5d2mac3NxcPvjgg84+AgCXXHIJl1xyyVH3k8SHWE1shRDc+cbXGA0Kl02XYYKSzlFlp+Eejy+oCyzpW4kH8luWSCS9nsDuD/jQ8lNuUbUQN2NIYJn80elYL5H0VGJVbtntDwKEK45JJJ2RqHPk8hma+P/m1CEJOX5vQvdgnffo5xysbkqwNcmP9GBJJJJej7/mMCcYSqg2aB4rsz0LAFNA3kQkycn/bp9Pg8fP2P7pMRn/l8u2hR/7gypGgwwrknSMP9gcShpUBUZDfEqA56ZqUQtpFjmdPRregLZo0uQL4vJ1r7G95NiRZ6REIun1BBsrtP/t/QAwp2oCyxpo6cESQsSk4pqkJbKJZewZNzA2wkoncsLsD6rYzFJgSTrmrnMn8K2/rga0nlgplvicLwvG9SPLbuak4bKtxNHwBiKvafkbHWtkiKBEIun1KE2hSmrpAwCwhgSWTW32YNlsNmpqauTkP8YIIaipqel2GXhJz8AnJ2OSLnDS8Gzmjclj1sgc1Dj+xu4sa2BjUR1uXzBux+yttLymZfGaWCM9WBKJpNdjdmuVpMyZmsCy5Q7l//w3IOz9+GNon/z8fIqLi6mqqkqQlX0Hm81Gfn5+os1Iagp+/i4AT195EgsnDYz6+L6gnIxJusZL182M+zE3H3Hw3tZyFozrH/djR5vSejcuX4D8bHtMPMZv3jyHS/66moAqWogtSWw4boGlKMpQ4B/AAEAATwsh/nK840okEsmxkuKt0f7P0hKdU9OzeD14GpkBc1hgmc1mRowYkSALJbFCUZRFwF8AI/CsEOKBVq9b0e5RJwE1wGIhxCFFUXKBN4HpwItCiNsi3nMS8CKQArwH/Ej0UNfnrvLG2AisiAmYnIxJjsYTK/YRVAXXzxuBPY75ULsrGgDNk9Xb+f7LG9hS7ODft86lcGhWu/s8s/IAW0scXD5jGLNH5XZp/MKhWcwZncfKPVUtFlAksSEaIYIB4A4hxERgFnCroigTozCuRCKRHBPpAa2pblqu1pcp1ard4J3egAwJTGIURTECTwDnABOBy9u5/1wH1AkhRgMPAw+GtnuAXwN3tjP0X4EbgDGhf4uib310iFX1Nt1r9fpNs2WzYclReerT/Tz04R7qXf64VhTcVqIJq+Vby+N2zFhhNmpT8kAH4qfJG+De93byn69LqWz0dOsYltAx/HLRJOYct8ASQpQJITaGHjcCOwFZL1MikcSNtziNlwJnktlfC0uzmAxcbl7JDcrbeJp6Ti8sSdSZAewTQhwQQviA14ALW+1zIfD30OM3gTMURVGEEE1CiFVoQiuMoiiDgAwhxFchr9U/gG/G9FMcB7FaQNDzrmxmmaotOTp6Wf85D3zCwWrZHqM76Hlk3g7ET6QnuatFPRwuP79ctpWvi+u5Zk4B+dly0STWRNWPqyhKATAVWNPOazcCNwIMGzYsmoeVSCR9GFUV/NlzAaqAb2c233R+ZHyTgcZqquvvICUtI4EWSmLIEOBIxPNioHUiSHgfIURAURQHkAtUdzJmcasx21007An3tVg5C35+znhqm3wMk94ryVEIBFUCESdiRwJB0jk7QmGOB6qbmDs6r83rwdBiSk6qpcsCqcHj55U1RQzJSuG3F0w6fmMlRyVqS1OKoqQB/wJuF0K0CYYVQjwthDhZCHFyv379onVYiUTSx3H6AqgC0qymcIgFgFvRbkCexvpEmSZJcnrCfS0YIw/W3NF5rN5fzdXPr2VXee/Pb5HEDk8rQSWrTh4fHXml1ZCIrW3ycfPLG/jD+7uOeUy9B5ZVeqTjRlS+aUVRzGji6hUhxFvRGFMikUiOhYa6WuYbvmaataTFdrcxFQBPkyMRZkniQwkwNOJ5fmhbu/soimICMtGKXXQ2ZmQJxPbG7DGoMcx32Vfp5OtiBw1u2ZRU0jEef8sS6fGsOpltN2v/p1ridsxY09E1HbmYsnxbOV8d6OxnrCW6V7Gq0cv6Q7WUO7qXwyU5do5bYCla187ngJ1CiIeO3ySJRCI5djxlO/iH5UF+Gfxri+2+kMDyO6UHK4lZB4xRFGWEoigW4NvAf1rt8x/g6tDjS4BPOqsIKIQoAxoURZkVur9dBbwdfdO7jxACQ6hfdr90a0yO8eznB1h3qA6QZdolndNaYMWz6uSPzxoLwMlJ1Gi4ox+n1sVDAl1YXNEFVqMnwCVPfcnybWXdNU9yjEQjB2sucCWwVVGUzaFtvxBCvBeFsSUSiaRTvA1aKo3HlN5iu9+UCl7wuWV4U7ISyqm6DfgfWpn254UQ2xVFuQdYL4T4D9oC4EuKouwDatFEGACKohwCMgCLoijfBBYKIXYAt9Bcpn156F+PQVEUDtx/XkyP8fiKfeHHsqSzpDOCqmBwpo3SkFcknueLtgZCXJsbx5r5Y9sPN85Ls/LitdPZV+lkybs7uxSK2Vr0ykWT2HPcAitUhUmJgi0SiUTSZXxOrUS7z5zZYrswaiv7QZ877jZJ4kdoMe+9VtvujnjsAS7t4L0FHWxfD0yOnpW9j8gJmSzpLOmM4bmprL7rDK7/+3o+2lkR1/Pl/BMGceaE/mSl9P4QwTSrCac3QP8OvNI2s5EF4/ozKDMF2NlhOff2aF14RObJxR6Z7SaRSHo1gSZNYAWsLRszBox2nMJGQN5IJElGUBVsK3Gwu7wxhmXaIwSWvIYkx8B1p4zgL98u5IT8zKPvHCV++NomZt//CWsP1cbtmLEioGrXnMnQPDX3BVQ2FtW1CA80GzWfRle8UDaTgfEDm6M8ZPPw2CMFlkQi6dUIl5Ynolpb3tTfGXYnk73Ps3vQNxJhlkQSM5yeAOc/toqzH1nJj17bfPQ3dBFVFS1ElQwnkhwLs0flcmHhkJCHJT7ooYGGJIij+saJg+mfbmXD4brwtp//awsXP7mapz7bT7XTyx//t4tX1xQBXVv4mDkyl/dvn89Pzx4Xeq+8pmONFFgSiaR349GKWCj2lknOesf6vtyTZdea99n0/guJNkMSZfSVbojNRMkfMf5lJ+czNCd+E2ZJ72PF7kqm/f5DfvrG13E/9hf7tEp6T67YH/djR5vsVAuVjV62lTZXvn1rk1bA9J9ri6h2enlixX7+vbmEU0bnMWNETpePod8XpQcr9kS10bBEIpHEG6NXE1gGe8ubjdUUupH04ZW68csXA1B34qlkDx6ZYGsk0SIyXCgWAkuffKVajPzhkilRH1+SXDg9AWqbfHyyq5JnVh5g9qhcJg+JX5ggwMHqprgeLxaEQ//aET85qZbwdZ+XZuXl61v3U+8cIQSKonQrvFDSPaQHSyKR9Gr+kXULp3ofonH4whbbp1cv4xPLT5h86B8JsiyxBAPNvYtqyo8k0BJJtIksz+yLQX5UUBXkpFrIsvf+wgHHSyz7jCULepn2miYf9763k7UHe38+VLwJqoJnPj8IgD/inDv3hIEA3Dh/JLpj2diNeMgXVx9i1C/eY0uJg//dPp9bTx99/EZLOkUKLIlE0qsp91o5LAaSmpXbYnuKcDHSUI7NW50gyxJLXWNj+HFjrex5kkxEerB8gWAne3aPLLuFjb8+i2W3zmF7qYPKxr7TlHT1vmo2FWk5MO9sKWX8r99n5Z6qBFvVs0lko+FkwRdQw57jyO/P7dO+2xSzMdxo2KAo1Lt8VDu9XRo/qApyUy2MG5hO/3RbFK2XtIcUWBKJpFfjcPsB2pTpVUyhUrdBX7xN6hHU+kwsDSwAwFtXklhjJFGlZYhg7Dwsz686xHmPruKN9cUxO0ZPwukNcMWza7joydUA/Prf2/AFVa56fm2CLevZePwtBZXM7+k6LfIqI76/vDQrQ3NSyEgxh6/7oCoovOdD5tz/yTGPr+ciW03GKFksORpSYEkkkl7NnQ3386j5MbKMLVfZlVAfLKWPCqwap48KtNL1aoP0YCUTgRjnYOlY+li+Rr2r+bfC4w8yLMcefh6rcvjJQCI9WFfNHg7AsFz7Ufbs2XSUVzlhUAYev8rag7XhiolWszZ1jyxGczR00bu7opE7Xv+a51YdjIbZkk6QRS4kEknvRQhODa7BbAzSlNbyBquYdYF17GEUyURjTSk+YeaL4CQOicHMSbRBkqiRn53CC9dM53/by5k/tl/Ux99b0cjVz6+l1KEtWvQVgZWfbScvzUK100edy0eKRVvtf+X6mShKEtQBjxGeUJiq3WLE5QvGJC+wI+aOzuMfXx4mw2aO2zFjQeSiSXZqczSG2x+kqtGL0xvAZFAYnGmjf7oVRQEhNGF2LDlZ3tDfqK7Jx4c7KnC4+3PdKSOi/0EkYaTAkkgkvRaPqwGbEsQtLNjtqS1e00MEDWrf9GBlHniHO81v8HLgDD4wnMJ3Em2Q5Lj4cn8N1764lukFObx03UxOG9+f08b3j8mxXL5gWFxB32o0nJtqpdrpo7bJR70rFH5s792T91gzd3QeVpORbSUOPthREdcQwcGZKVxYOJgT4ly1MNroHqz+6VZuP3NseLshJOxVVTB1WDar7zoDgLG/XI4vqOIPqhysdrGnwsm5JwzqcHz9b5Jm06b98RTBfRUZIiiRSHotzjot+bxBSWuzwmwwa0m8hj4aIiiatOIeNWRS4eg7RQqSldfWFeHxq3y+N/ZFW1p7rPpSTk12qiam6l1+6kIhg9l2C2UOtwwT7IA5o/L44RljmDe2H3aLEZMxft6+7aUOxg/M4JtTh8TtmLFA92CZWnmjHnx/FwBlrX7DTRHhu+c+uopbXtnIjtKGDsfXc7DSrJrAaq8UvCS6SA+WRCLptTQ5asgDmgzpbV7zZY3k2cA5GFImUxh/0xKO4tIm4lb85DRsB+Yn1iDJcVHZ0BzqWlTj4pGP9rC1xMEtp43ioqn5UT1Wa0EV6EKuR2/m9XVH+OqAVmK8tsnHuz+cR12Tj5+8vpmvDtSy4s4FjMhLPcoofZcrZw3nylnD43rM5784yJ4KJ6eP709emjWux44mQgiy7GYyUtr3lrYWXmajAQgSCAqG59jZW+nsVNheWDiEiYMzMBoU3tlS1mfCfhOJ9GBJJJJei7tBExFuYzsCK3c8SwJX8ql9YZvX+gJmrzZR/L7pv7ys3oXH2zdz0ZIFl6+5r1lFo4e3NpWwt9LJve/ujPqxWjfn9gf6hufmYI3WrHZAhpXJQzLJS7MyZkA67lCVvDpX3/SGH431h2r53/byhJTzb/JquUWlDnfcjx1N8rPtPHTZFIpqXdz88oY2r1tMBj7fW8XUez7gh//c1NwwWFXD16vF2PGUfvaoXK6aXcCkwVooZetrXBJ9pMCSSCS9Fm9jjfa/uW38vTV0s4lFn6DegM1XF35sVAQ15bJUe2+mydd8HgeCkX2woj9R0scsHJrFslvmcFsfaUpa16QJqB+eMaaFp8oc8h4EZN5Ku/z10/3c9NIGvj7iiPuxS+o1YXXXv7bG/djRRkHB5QviDlVlDESIIKNBwetXqXP5cXoDPHDxifztypPIsJnD1+uxFLvQhVlfCvtNFFJgSSSSXkutSOPD4DTKUie2ec0m3MxUdjLcvSMBliWe1EA9AH6hVUKrryxKpDmS48QdIbBaNBqOwUq0XtRiUKaNqcOyGZrTu0tgHys1IYGVY7ewr9LJtS+s5c8f7A6HXgXkqn+76FUENxyu4/Q/fcpdb/V+sZMIzKFFQT18zxMhgk4f379Fo+EzJw7g7EkDsZmN4fysTUfqOxz7ox0VvL7uCB5/kKnDspg4KCNWH+OY2FfZyPw/rOClLw8l1I5YInOwJBJJr2W/vZAl/ju5dlgB57V6Lc11hKXW33OoYThwXSLMSygZqraaXGQeyajAXppqpAerN9MUESLYoilpDLwqI/ulcutpoxjTv23obTKje7A+2VXJmoO1rNhdhTegNk98VenBag+90bBBgQPVTQzv5T2pjoV3tpTyxb5qlnzzhGPyHB2NXeUNfPe5NUBzSK6+qJKbauGMCQNYvlXrZ9hRJKCxk1YCT688wNpDtbx24yyW3TL3uO09Xv7vzS0U1boob0jeAkxSYEkkkh7J7rIG7nnpPa46dz5nTx7c7j4Od6iMcoqlzWsmi1ZF0CT8sTOyh8nJQfsAACAASURBVBJUBd/2/ZIcGrgzZzPU7sVXJwVWb8Zk0GZV3z91VAsPVlAVx9wL51iZMCiDCYMy2FPRyK/+vZVR/dK4dm7y98ypDQmsNzYUh7dlp1pweTVxKz1Y7aMLgfRQL6q+UNb/tlc3ATBvTL9Oy6MfK7pIhWavtN7A2WbWohB0D5bRoLB0XREVDV4unzEs/L7OfgK8ep6WKfGBazvLGthYVI/VZODq2QWJNidmJP6blkgkknbYt+oNXnHdhPXTezrcJ+Aoox91ZFnb3tDNVm0VtS8KrDqXj93qUHbZChHpmjgVjWUJtkpyPHzvlAK+O2sY3z91ZAuBBbFrBFzu8PDyV0V8sqsyJuPHGyFEpyKptp0iFtl2M0aDHrqV/MKhO+ghgul6j6UE5Pckqg90gzs695dghFda91Bn2MzcOH8kYweksbXYEb7uDYrCi6sP89CHe6iI8AB11gzbGxJrFqMBX0ClyRvocN9Y8+jHewG4YuYw+mfYEmZHrJECSyKR9Ehc9dqkLsNb3uE+ZxU9wjrbrUysX9HmNZNV++E290GBpa/E56RaMGZpAsvYVJFIkyTHyS0LRrPkmyeQZbeQZjW1yKGIdh5WUY2LT3dXhgsIJEtC/N1vb2fGfR+3W+1OCMFlJw9lekF2i+3ZdgvfmTWMJd+czKTBic1b6al4Q96XsMCKo6dv2S1zAK1BbyKIlrCLLKCihwhm2s1MGpzBit1VPPP5AdQID5ZerCKgCs6cMOCotuh/E29AZeyvljPr/o+jY3gXcfkCvL9du6crKCzbVHyUd/ReZIigRCLpkZRrFZPbrNZHYgxoE0CTrW2uiDnUaNhM3xNY7iNf8wfT36hXTiQw6nIuXquQZx3DnEQbJuk2voDKu1tLMSgKFxYO4b0fzcMbCGIxGjpdue4O720r44HluzhpuCY2kqVnzktfHQbghS8O8bNF41u8pigKvzh3Ak5vgMm/+V94e5bdwmnj+sfVzt6GXvVO7+EUz/PFEDr3450eZzUZ8AZUTi7Iicp4kfe5m04dGX6sf76gKpgwKIM7zhrL2IHp/O2z/YAWtqr3yOrsXtlaBCfqmnb7guj9up//4iDThmVFvY9fT0EKLIlE0iMpCQkso9px/yaTqgusts0/zX3YgxWo3M1lps/YGBSkD/gZG8VYRrplg9TeitsXZMXuSn689GtSLUYuLBwCgNVkjMnx/CGPVapVmyIEkqy4w96Kxg5fS7UYtTCq0AQ0J7X9xq+SZj796QI8viDVTs1zHs/J+6j+aSy9cVb4XI0X88b0o7LRQ4YtOueHfo3NG5PHxdM0wVFa7+btzaWAJp7GD8xg/EDNi/rcqoOA5pE6FOrf1qnACl3TadbEhXFC2zDbZPttiUQKLIlE0uPwBVQe8D8AQHqgtsP9zKoW6mOythUPVlsKABb8IETigvQTQKCxCgC/LYcUizYJ9/j6Zj+wZOBInYtbXtkIaJXshBBR91pFoouL1NC5kywhgjrt5X3UNvnYV+lkUKaNLLuZykYvYwekMSzHzvpDteypcDK9IJsxA/pWZcVjIcNmJsNmRlEUvjd3BAMz4xeud9lTX+L0BvjvD06J2zEBnr365KiOp4ujyGI1W4odfLRTC+3WC1zo6CGC1U4vu8q1BYMp+Vkdjq+LXrvFiKJoHr9oF8c5FqwmA9+alk9RbRPrDtUldV6jFFgSiaTHUVpRQUHocUB0nCpqDnm3TLa0Nq9ZzBbO8P4RHyZWxnhC2tMQTk1gqfY8UoSb35uex+Q1A2ck1jBJt3BEJNIHgiqvrz/Cz9/aihAweUgGf/3OSVHtVRUWWNbEhhNFG5NBIaAKfvONtn3z1hyo4eZXNnLWxAHkpFqod/l59PKpjB+YwS+WbeXVNUX8/sJJUmC1QghBQBWYjQb6pVu5u53vNpYcqXPR6Il/wYanPtvPuoO13LxgVFTCBIfm2LnulBHsLm/k7c0lXFg4JFxFEEBVBUU1LnaUNTA0JyVcVdQVWjgbkGFlWCfl8TfffRb+oMBsVDCHCl34gypGQ2y84B2RnWrhz5dNYXd5I2c/sjKpK3NKgSWRSHocNUd2hQWWSW1b2UvHEvJgWVLaerAMBoUiQz7+oMCnCqzdLOlT2+QjzWrqEeVtjxXFVQ2AITWPFJPClaaPaBQpCbZK0l0crmaBpQotzEZf0N5W0oAzyhXBdI9VZoqZ8QPTk6LRsBCChxYX4vIG2g2t1CsI5qZaeOzyqVhNzblt5tAqfzKvtneXxz7Zx+r91Yzsl8Z9F50Q9+Pr4uqpz/a3yauLJRsO1/Hxrkq+OXVIVMYb3T+NH54+hin3fMDXxfVcWDgknNsGmgfrsz2V/Prt7Xxn5jAyU8zkpFrCIXbmjppjhVAUBYtJO4+tIYHlC6rhEvDxRm/e3VlYY29HCiyJRNLjcJbvCz/uLLDNKjSBZbO39WCBVpLWHwziC6jdylepd/mY+8AnzByZw4vXzujy+xOF2VsHgDE9D1uK9t3Y8KGqAkOcQ0Ikx0+Dp2UeYeTKNkTfw6SPV5Br59fnz4/q2IlCURQumKJV1HS4/DR6/eRnNwvH2lD+UHaqBZvZyIEqJ1l2C9l2M6bQ5DWywbME3t9WzkMf7kFR4IZ5IwkEVTYcrkMVMHtUblxtWbaxJK4C68MdWuieO4qh12aTLuTVNmPr/e5ACyN89PKpAOyr1MIDi+vc7C5vZNzAo3tYzSYDeJtzLeOJ2xekqNZFjVOLPvEn8TUlBZZEIulxBKsPAPBs4ByesV/Pmg72+xm3Y/A18Mf0vHZf/7XheTLMdfgbTwLbwC7bUVzbxIjAfuxHtgO9R2CZAlrSs8WejcFswS+MmJUgbq+XlJTk7TuSrDha9drxtpoYRVtg6R6so62K90be2VLKba9u4rwTBvHEd6aFt0d6sHwBldP//BlGg8K+e88Jr7ZLD1ZLngpVsvu/s8dzxoQBNHkDLH76K+wWIzvuWZRg62KHENE/D8odHnaUOYDmku26B+viqUP4zTcm8eZGraS5ISLc3RdotmXtwZp2BZbLF+DSp74ky27mletn8dsLJqGqIu6FQQB2lTdw0ZOr6ZduJc1qwm5OXhmSvJ9MIpH0WswOrZxykejfosN9az4PjMenqthS2g9hms9GBhurqHQ7gK4LLEo38Z71F6BC0HcLRkvvCLMrVgaiqAWYMrTy0h7Fghk3HrdTCqxeSGuB1dqDFTnJiga/PHciPzh9DFl2rUJaMng+Kxs9/HtTSThnZVNRXYvX60K947LtFp75XFvgCapa7qY5lO8SkAKrBTVNmhfinMnab6suyJO90XBk5btoVcFbta+aO9/4OjymqorwdT48N5VMuxm1nUIYkT3HOrLF5QuyvbSB3FQLQNiTmwh0G4fn2Hnz5uRuHJJ8y1MSiaTXk+4+AkCRGNBmMqkTVAW+gIqiaJWJ2iOghPqyeN3dskM0NDc5bqgu69YYieBh8418w3cfpnwtjMSLVtXL43Ym0ixJN2lwa3kmPzlrLLuXLMJuabk2Gu3Grpl2M0Nz7BgNCqN+8R6TIvpC9VaO1Lq4771dfLKrEoMCpQ5PCyFQozfnTrNwpNbV4r2mcFPX5A1n6g56/pPe/yqy+a2axLk1kUI7WudEsNU4flUNhwimWLT7WzCi0fADy3cx+/6PeXPDkYgx2v/O9XESlW8ViR6WqF9TyYz0YEkkkh6FEIK/+8/ky+BwHjI/SY3IRFUXtVlBd7sa+ZnpnzQZ0lGU89odK6CYQYDf13Evrc4IeBrCjxtqy8gePLKTvXsOetGDcM8TxQYCvC4psHojPz5rDFfNHk5GihmryYjaKkQpVrkUZqOBoCrw0/uFhdMbaoZrM5OXZqWy0UuV08uQLM0rXR8qJJJtt7R5rzmcg5W8oqGrCCHCAktvXqsoSriHmF9VscahQt03Cwfz782lxCBqr0MiFzSiFTbaeo3EHxT84twJXFA4mAff30Vlg5fskAfKoCg0ePyUOTwMybJTODSLzUfqOzw/9UVKvWXHf74upbLBw4WFQ+iXHr+S+qC1mYDkDD9ujRRYEomkR1Hn8rPMezLptpncKN4hx+BsN3fI21jPzab/Uk0nvT8U7YYU9Hm6ZUvQ0yxImmp6jwdL9TSiYCQtNPE5aBpJuTeN1CTrZ9RXSLeZSY9oaHrq2H5kpphZf6iWFIuRgZnRDft85KM97Cpr5AdnjAY0YRHr3luxpim06JBqNTIgw0Zlo5fKBk9YYP3typNo8PgZnpPKpSfn89q6I5w5YQAA3z91FDefOqrXh0lGE7c/SFAV2MyGFpNls1HBF9QEQjxSfH5+zgRNYBE/hRVZWlw/f46XNh6sgIrBasIfFHyxr4Ymb5Azxmsh30ZDc2VLm9nAnFG5bD5S36EHSw+zt5m1v9MzKw+wtcTBjBE58RdYoXuQKgQL/rgCg0HhkzsWxNWGeCEFlkQi6VFUh6oL9U+34W20YMeLx93UVmCFwt28Ssc3iGBIYAW6KbBUb7PA8joquzVGvFGDQb7kGoQVMGnl2h/K+TUbDtfxRkp+Yo2THBc//OcmjtS5ePyKaXx31nC+O2t4TI6z9mAtq/fXcOXs4c0eiaAIl3nujTjDAsvEgAwrW0ugoqHZsz04K4XBaJPlk4bn8MXPT2dAaPIZ72asvQG7xcTee8/B5W0Zwm0xGWjyaZVbicPc3WxUGNkvlbzU+AkF3VPUL93KosndyO3tZMxLT8pnyUWTsYREq37uqUJw/byRXD5zGDazkYc/3KO9LygwhfbpKEdQL5aREgoRNBtbViuMJ3pIpc1k5FCNK2x7MiIFlkQi6VEEnbV807CKVDEAL1bsePF5moCWZX99Hq08rU/pePU+YNBW/YP+7gksIgRWoLGie2PEmSang3RF4BJW7CbtJ16/sUazpLAkfvxy2VYaPAFW7KrE6Q3ginLfq9boEy+z0YAp7JFQe1UvuNa4IsJm9ZYNlY0d/y5EyzORzJiNBjLthjbbID6T96Aq2F7awJILJzNndPuVZGNBus3EHy85Maphbrr3SQ8DBvj9Ozv459qi8OspFmM4zE/PYdpcXM+7W7Toitahwzp6iKAtLLA0u1tXI40HvpAItIU+RzJ4xztCCiyJRBIXNhyuY+m6In51/kQyIsKdWqM4DvGI5Un2eUZr3ikBPo+rzX4+t1aK3GfoeOXyiHUMjW4/KYa2jYiPCX9T+KFwVnVvjDjjctaTDjQpdvTaijazESNBPN7u5aJJEsuKXZWUOjykh2Ku1h6qZcPhOgZm2shLs4b/jxZ68QeLSQ//CiZktTuaNIUWF1KtJi6YMpjzTxzE2AHNJa1/8M9NWIwGHvzWCeG+VzofbC/n8RX7OGP8AH505pi42t3bWHrTbAwK4Yp1scQXULnq+bVYTQZ2Lzkn5sfTsVtMnH/iYBq9fho8/k7vZ8eK7sGK9OjsLGsIV71sHf6nV7bcWablCV9YOJgfnzW23bH7Z1i5fMYwRvXT7oP6Qkki2g6cMjqPN78/m8wUM+9vKyeoCgKqCHvVkoneuxwlkcQIVRWsPVgrV/ujzAtfHOT19cX8Z3Npp/upfq2aV1Axh3OoNA9WS/whgeU3dOzBeiv3Jr7j/yU1WSd0y+YScwHr1bEs8X+Hd7Kv6tYY8cbdWK/9b2guXX9z9RL2264ku+j9RJklOQ70Mu25adr18PbmUn7+1laueWEd5z+2ive2Rjc/UF9lNhuV5tLbvVxgCaHlC6VZTUwYlMHc0Xnh/JNAUOW/X5fy1qbidsMB691+thQ7KKptu9DTV1l3qJYLn/iCB9/f1WL7iLxUhuemthGpsUAVbcuWx4sXVh9kxr0f88SKfVEZ74qZw/j8/05jb6WTi5/8gqIaVzi0D7TPunRdEVc9v5Z3tpSGPVh6iGZn3rTxAzO4/+ITuH6eVqRJDz9MRKPhnFQLJxfkMGZA+lFDG3s7UmBJJK14f3s5l/3tSx79ZG+iTUkqMhr38XvT8+RufrLT/YJ+zcuiCSxtAuRvx4MV9GoCK2DsOJRHX6nzBronllelLeIS3295Nngepe7El7g9FjxOTWB5Irx2wqhNzFWvnCD2NgJBlSZfEIMCmaEKd97QxEufV0a775AvdL1YTQZ+tmgc9198QrgiZW/lttPHsOv353DLglFtXnOFvk+72dhuqJJZlmlvQ7nDw9dH6jlc03bxK17oAsvlC3Lykg/jdtxqp5dX12ihe9ESBxk2rTVCmcPDxqJ6Gr3+Fou8QVWwv6qJlXuqKK5zM6Mgh1tPG8XUYVqRp66E78YzjLMzwgIrSa+r3v2LKZHEgO2lWjd13fUuiQ5XVj/CBNN23OWrgAc73E8XWKrBxGrraayoG0ehMbPNfl5VoVjk4TTntnlNJ8UQIAMngW4KC5evOdel2unr1hjxxteknb8+Y4TAMmkiVPVJgdXbcEUkqFtCE329KliK2UiTLxj1UB9/sLmU8qUnD43q2IlGURRqm3w8+/kBjAaFOxaOi+g31P6UyCQbDbchXKLd2jI87s8f7OZAVRM/PXscBXndDM0+RiLn5a44RpyU1LkprtN6KwaiLFKaC1CIcI7UyLxUZo/KDYcJGhWFOaPzmDM6j+dXHWT5tnJeXVNEfnYKtywY3WbMigYPFQ0eBmbY6J9h03K5zMY41l1sZvW+aj7YUcHsUbkhL2cwaa8rKbAkklbkHXqXf5iXcbB8MjAj0eYkDRnBOgBS8OD3ujFb2/c8qYHmEMEPsr/NyqoqXrC2rdRUlDOXS72PcvGQIZzSwTEvq3qMh2z/Zd2hX8P0O7tsc4qrhPFKCbea/o211gL8t8tjxBu/SxNYflPz5EYNCSwhBVavQ/dOWc3GcCiUJ9Dc1yZcsS2KzBiRw/BcO6m93GvVEQFV5clP95ObauGOhePCk3O7pX0vdSKrrvVUGj1a2KreA0tn1b5qNhXV871TCmIvsCKKOnRU4CEWRHpc/FHqjbZsUzEf7qhgS3Ho9zvY3Gj4lRtmMigzhd/+ZztAi3YBkedkWX37RVve2ljCg+/v4qb5I7nr3Ak8vLiQhxdHxewus63UwYurD2EyKFwzpwBfLy+e0xnJ+espOS5E+TaUtP6Q1j/RpiSEhZXPMcRYwnzvVoT4a6+rbrOnopHcVAu5UUx6jwaR96EjuzYwckr7skgNaB4sYTBjC/3wevxtVyf1lX1bB5MiAGHUvgMR7F5xh1sq72G0VQsV9QWMIAQcx/mgqoKgEDFtslhqH8/LvpuZMHwMU/WN5pCY9btjdlxJbAgLLJOB+WP7MTgrhf1VTRyucYWrgkV74v+nS6eEH3+wvZwqp5dFkwb2uN+UrnD7a5vYWuLgj5dOYUp+FgYFapp8+AJq2FPdkcAKe7Bko+EwzU2GW3qw9PweXyD231UwUmDFUftGeoyj5cHaVdbIe1vLI46htimvHs45U6DM4WZXeSNbSxzh9wSPUkXQak58mHvYO24ydFiUI1lITtko6TbuygMoT82l/LGFiTYlYRgiJuP1DY0JtKTrVDu9nPuXz7n55Y2JNqUNVtG8ula7b12H++keLNVgJl+UMVPZiXCWt9nP42t582kPPfeIQPcEllVt9vhYlCCuxtpujaPz6UPfYduSuTGt5ldh6M8ydR5lebOaN5pDBS+kwOp1mAwKC8b1Y9bIXG5ZMJqHLisMVwOLlcCK5IkV+/jlsm0cqevd587hWhf7q5oQQmA0KOECF1VOb0SIYAcCS3qw2tDQgQeruUJd7L+rRHmwIj9btMLbWot3f1Bw3omDOO/EQTR6AlQ0eMIhggaDwqe7q7j2hXW8s6W5wE0wwpZyh4cnVuzD4fKHBVZn98p4EdkCItlJ/k8o6RKHd2gT38PetARbkhicbg/9RPMkuqrkQAKt6Tql9W4CqqCkvudNhmw0CyxRuqnD/Q4NOIsJnud5M//nnFv3Ekutvyen7PM2+0068CwbrTcyv+qfHY4V9mB1sw+WLgq9QluldVR1XgGxM4QQnO58l6liBxV7YyeA9YaqkSvLikUTWEqg550Xks7pn2HjxWtn8PDiwvA2faKlT5iiXeGvssFDXZMPEeFt7e3iosmre6k0QdA/Xas+WtngwWY2MntkLicOaZvrCVoT4sUnD2XBuL4Z1dEezR6sVgIr7MGK/fmSY7fw2U8XAB17b2JBpKiKVohg6zLs/oDKfRedwN3nT2TeH1Zw/mOrwiLSoCjhAhHfmpbPHy85UbMrYoxrX1zHH/+3m1/8e2vYE2Yza3+bp1fu5/Q/f8proR5b8UT/7swGhU1FdazcUxW+NpMNGSIoaUFTiRbjuyMwmBN9wQ5X9JKV8qJ9jFaabwz1ZQdhYmEn7+hZeKsOcqdpKeXe4cDpiTanBSnCC6HoumzHjg7386oG3NjAkoowapMg1ddWGBi8DeQoTiyGTm7kplBIU7B7BSrsQjtuqWEAI0QxDTWlDBrVvZLvjW4PGaHHddVlDO/WKEcnr3I11xrXM8xvArQQjNr+s/nZ1hsYnDaN2TE6riT2lDs81Lt93HPBZB6+rJDKRi8VDZ6wNyYaCCGYef/HCAH77zu3WWAloKRzNGkKlbPWqyEOyLCytQQqGrwsmjyQf944q8P3jh2QzoOhSWxfRAjB45/sI8tu5srZBQBML8hBAUb1b7kYG09BbjIaGJZjD9lI3BrWRn62G0Olz48XPa9reK6dk4ZnMyBDu/cZQp9HVQUTB2eycKKPYTl2apt84ffpuZnBduIka50+UkPzOH1BxukNcqCqifKG7i08Hg9hD5bJwP+9uYW9lU7+d/t8xg1MP8o7ex9SYElaoFRrPS32iHzKHG5G9utbnqy6kpal2T3VhxJjSDdRqnZxm+ltnGoK8PtEmxPG7/NgVrQJzlp1HFv84xihinb7l+gTOYvREK5+154HyhAIhe+ZO06kVnSB1Z0QQSFIEW5QoM4ymBHeYjz1FV0fJ0R1U5APg/P4lvFz3NWxWzkcXfUJ3zW/zbqmAuBsAPy541kadHOeeVDMjiuJDd5AkAZ3gBSLkfve28l/vi7lkcWFfHPqEAZm2hiY2XEfuO4QVAVCaL2FjAYlHB7X2/tgNYXyrPTCHf10D1Zj/CeZvY1DNS7+/OEeAC49eSg2s5ErZg7jipnD2uxrNsW3b5qiKPzqvAlhIRIPVKEVPjlzwgBOyG/f69lVdM/OTfNHccXMYfgCKttLHeGcpaAQXDlrOFfO0pbm3tlSGn6fMVzuvNmDdfHUIdxb1sDEwRlUNmr3P33BXBdc8ay8qBNZodQoy7RL+hKZjfsBuN/8HNu3zYLTLkuwRfHFU7m/xXNRH38X+vGgOisBSFPccVvNOxZcbg8bg1MwGxV+ZP4VNU0+vuH0hlfpIhlWupyllr9TV3M+whx63d+2+p0hFO5msNrbvKajmLQcLKUbHqygz41REXiFGa99AHjB5+i+wKpq9FIitJLyav2Rbo9zNEx+LW/QmJIR3qavXLrbKRYi6dlsOFTHFc+uYdbIHAZnaQsOsfQO+MI5EtpvR7gpaS8vpayHIaVatWthVL9UJgzKwG4x4fYF8asqdrOx3Qa5Hn+QfZVOLCYDYwck30r70Vh7sCb8eEdZA9OGZXe47/iB6dQ4c8lJtcTcrspGD795ezv906387sLJMT+ezqLJA9l777mIKIYl6uJID/2raPBw3qOrwh7X1iGEeuGVd7eW8e7WMmxmA/PG5IVf1xcSmryB5iIXJu3ct4decyYgNC83zcKY/mnkplrC3k5Zpl2S9Ag1yOBAs6DwVh9MoDWJweOoIigU6oy5mIMunO7YFSOIBX5vcyid1x/AZjF3snf8cGPjWv/PGJBixW4yUNMEXn/7k0S7q4SZhl2s8U0Ha8g71U7ukJ5PZLB0LLDK+5/Cbds8jM+e1uWC+25nPWmACxuOrIl8Un0Et8jq4ijNNNSUkxbKQzM1lnR7nKNhCji1/+3NAiszUM13jR+S6xgCTI/ZsSXRR++FYzEZMYcmVb9+exsvfXWYi6cOYU+lkwmDMsIr28eL3mNLL6ARrZCvoCpQaFliOl54A1qvMJNBCQvG6+eN5PpQeNeznx9gybs7uXZuAb/5xqQ2799f5eT8x1YxfmA6798+P6629wQ2HK4LP95a7GDasGy2lTiwmgyMyEttIUpvPW00t57WthdTLHB6AizfVk5Bbsf3gFhxpNbFWxtLGJxli0qvuDH90zhldB4mo8KeikbqXVoRkVSrEac3gKoKqp1ePP4guanW8AKIzpJvnsAlJ+WHn5c5tPvjoZom/njJFH5w+uhwOGXYg5UAgRV5fvz9y0NA8nqwZJELSZiqI3tIoXmlX60vTqA18WHXilc4cP8s6su0YhavWr7FeO/feemk15nifZYnDZcn2MKuobqbmyN7XM4EWtKSJl9zgvlgQz2jlBJ8ng7s071NJjNKqPqd0k6IoDGobTN24sHyZozkHXU2RZZRXbdZSeVS793cZbqD4pHf5nv+/2OdbU6Xx9FJ3/8O3zO9D8CRYMcrwMeLJdik/W9vDl3JcBezxPwCZze+FbPjSmKDN6JMuymi0fCWYge7Kxp5dU0RK/dURfF4oYT40Gq3OQpV4YKqYP4fVnDRk18cv4HdQAi49bRRXDdvRLteffdR+2AlR6GP7nLvRSdw8dQhAOGy4N95dg1nPbySBk/iChToTp1DNS7e2lgc17/PkToXD3+0hzc3RGeedNOpo3j5+plsLKpj4cMreWO9FuWge6KCQvDb/2znlAdX8MGO8jae1ta9pF744hAAXx2oZWiOnRPzs8iya15FvdBLUwJCBCMxJ3kDbymwJGEOVjp4NzgDt9AuQpMzdqvsPYXxn93CSO9OHG/8AIAjdW78mDhpjBZb3hOr8XWG4m3uieF19xyB5XG7yMVBpinAve4lfGz9KVTuandfEdRW7jBaUEL9m5RgW4FlCm0zWTvOwdJvhRuOMAAAIABJREFUOt2paOUMGlknxrPLVhgO03Afxw1JNGrhhX8JXMwjwUu7Pc7RsIYEli2tWcSZbdp3ZBEy36S3oYfsWUyGNqWNY1GmXfdgWUMVxx6+bAoH7z+XCwuHdHtMX0ClpN7N18WOo+8cA2xmIz89ezx3nTOhxXYhBB5/MNxTT594tsbUTo5LX8JsNHDdvBFcWDiYuaNzEUJEVCtt+Z0FgioOtz8ckvnRjgq+3F/TZsxoEBmi95PXvw4vRsSatzeXcMUza4DonxP6Na5XaYwMEQz3wTIozByRw6qfncb0Au13fkdpA/sqm9vK5KVp87ixA9rm0ethsnr/t0TRXu5YMiFDBCVhvnb34z7/7Xwjcz+PeX+N3V129DclCXUuP0NVwZFaLddn6rAsLCYD9S4fTR4/qbaeEWp3NAy+Zg+W19WUQEtaYihZzwbbzexomozfYIUgBNqpDAgR+VJGKxXDzuWMTVnMzBnTpvrdh7aFvO8czVk5HXunsjzFfN/4H/Lqx0Jz291jwhWqOpZqNWElQD/qMHs7FnNHw+DWvAxVIpNyh9bTpL0iH8dLSqh3ly29OZzRYtdusma1d4W8SiIaDRsN4Ym+TkpMBFZLD1Z7OUldRfe8xeJ87y4Hq5s466HPGJpj59Sx/YBmwdqaZM8VORYmDc7kL9/WfkObvAGCqsBmbiv6//LxXh77ZB+3nzmG604ZwfX/WA/AoQfOi7pNrUuzx6sXVo2zOdInWo2GGzx+VFWghErtRvYZe/aqkzEaFZau1bxaBkXBZjaSn20PC7CnPtvP9lIHL103E4DR/dM5VOPijoXjeGD5Lho8fn585lj6pVsZmm3nmjkFjO4f/yJmt766kQ93VPDot6cmfX85KbAkYXaXax6PgpHjYSdk+buf0N8bCPi84Qvg6qbb+E95BZ8Zb+agaSjptvN403IPY4z7KCv5gpGjekfHcWewObHY21EIXgLwh2zxG1MwCu3G0aHAUrWbl2I0Y0jNZb8YwmjRNrH8I+M8tgensCin49yTLNdhfm5+ja2O6cAdXbJZrdzBr0wv4QlOYmj1ENbZfszGslOBBV0aR8fi0QRWjcggS62nqr6RgTkZR3lX1/ELA36M2NMiBJZNu5FaRfIJLEVRFgF/AYzAs0KIB1q9bgX+AZwE1ACLhRCHQq/dBVwHBIEfCiH+F9p+CGgMbQ8IIU6Oy4dpBz1kz2o2tBE7ekibPxC9ieWQ7BSeuerkcM+caGAKl5EWCSm+U9vkY2uJgwEZVsYP1K65dJuJgCqod/nCK/kdhQgm+0SwM37z9jb2VDi58+xxnDRc85Y098Bqu/CoewHdviCRjgl/UI16c9nWqTtqNzwhjR4/VY3eLlVMjswZ8kVJdP/4tc18vKuS8aFy5XV6DpbFxJkTBwDw6hotRz6yYmJk8ZnIBQDdRrNR4b9fl1JS7+bmU7XFyIK8VH57Qdtcw3jg9av4AioGBf54yRR8AZX+GdFrM9GTkCGCkmaK15GHg6mTJqAKhVy1tjlcKwmpKt4HQLHIw+E38s6//sFApY4hFs0DkGYMkKL4qCvrPcU+nku9nm1qAQABT8/xYAVCAitgTCFg0H5Mg0fzYJks4Umep52CGHq4XkerzgAGs3Yso9r1KoKGmr1cb1rOLP9X4XEM3RhHx+7TGlj/1fIX1ttupu7g5m6P1RGqKljge4gx3n+QmtXcFNWWEhJYJJfAUhTFCDwBnANMBC5XFGViq92uA+qEEKOBh4EHQ++dCHwbmAQsAp4MjadzmhCiMJHiCpo9WBajge/MHMab35/N4FBpdlsMGg1n2MycNXEA88ZoXp3nVx3k/Mc+51/HkWtS5mgOTU1EONDWEgdXP7+WJe/sDG/LTAk1D3f7w7koHQosPVckSUOZOmNDUR1fHqgBBHVNPj7ZVcGqfdUAZNjartHr4WdNvgCZKWay7Nr33OCO/lyitceqO3+eBX/8lNP//Bn7Kp2oquCjHRVUNXb+O9lS1ETn2tPPLf2argj1qMpNaxYfuoA0GhSO1Lq46aX14b8FtKw0qC8GlNR7mvMqO7lXxotwHyyjgYGZNobl2nuEXbFAerAkAKiBAPc6fo7N5scx5CBPcxFVgRR+6HSTmdk7wuO6Ss2RnQwCDqsDMBHgkuonQAHflKsBaLQOAP8e/HWxK6kdbRo8AX7kvxUDgt/Zu17YIVYEQ2IvaLKjhMK+g77284EO2SZQHqwiO2Mk2a6DPGx+gkDtCGhVB3CG5wvGGPykGDouPGGyhJo1ql2/uQfcWjx7wGQnJVQuvjtCTScjoAmsw8ZhDA8W4aw8CES3IpnLH0QIbRXZGLFabE3VQhttyefBmgHsE0IcAFAU5TXgQiCyk/WFwG9Dj98EHlc0F8qFwGtCCC9wUFGUfaHxvoyT7cfEGeMHMCgzhaE5KQzNsTM0x05eupVShyfc16Y7OYbHSkWjh20lDVQcR7+oxohCCIGgIN7zqdYl2kGb4KVZTTi9ASpDk9mUDkME+64HS//bZdst/HdLKXe/vZ0RedrvSWceLD3EOjPFTL3Lj8PtbyEWjpVyh9ZIu73wUrvFyCmj88Iio3Up82PBERJ+Td4A/91Syo9e20xempX1vzqzw/dEngfREt267fo5ePakAVx68lAybGYe/Xgv/qAaXkgxGrQS6//brkUZLZo0kPe3l7fwrOk9rn79723hqoH6gmUgqLL5SD3egMrc0c2l3eNBs2ct+f07yf8JJcdE2eGd2BQ/5eSRmZ3DvzKv4bngeZT0HCdI1Dngy+KvgW/gMOWyz3YVA5R6apUsRi28AQC/KZRv44vDlxD0U/3JY5Q+ezmBhspuD9Po8bNfDGGvyKdJ9BxhLLyaWFHNdoJG7Sar+tv3YK1OX8Tt/tuoHzgHe6CBi4xfcIJnQ5v97go8wd8sD5NKx6LHGBJGZtF1YaR6Qjab7BhN3feEAQhVJVvUA1CdoYVm+Gqi32OtMRS3r8fl61isdlShoKLgDyQ2sTnKDAEiV0CKQ9va3UcIEQAcQO5R3iuADxRF2aAoyo0dHVxRlBsVRVmvKMr6qqroVfKLZFiunUWTBzJpcHNVyLMmDGDxyUMZnqP1chrR7//Zu87AOKqre6ZuVW+W5Cr3buOKwWCwAdM/aoAklEDoHZIAIZQQIKEm9CQQCDUQenHBGGyDuzHuvVtW79K2qd+PN292drVdu8ImOn8sz055OzvlnnfvPSf13sBw7Khtx9MLdmDeJtKDK6ah/8hKAH8MSeaOQKjJMAXNYl0ypS/+dtE4jOkd2YbBbePx8Q3H4N2rwztBf/qg5NRt4zF5QD4A0r8GdBa4AIJZQK+kwhNQ0Owhz8xU1AZX7mnE1EcX4vq3Oj//AaCiyI03r5qCoizyfI7nS/XCol14Z1Xoc7ePIV2eZeexZh+Ro2/oiD0RZb0X6DXUVdD7ImgGzOOovnkYVOzGc9/swrNf7zJFPFiGMUl/RZEL184gk6lWgmktI/SEVXsomo7zX1qOK15dnZaxJwNazixwDF5fvg/Xvfl9xkRQfmz0ZLB6AACo270e5QDq7P3RC0BZrgM76zpQ3erDiLL094kcDlgfKMMrysW4dXI+Tlu7BABwcNAvkW8o1+kGEdDlzM76t1Tthu/Vs1EqH8QbyiwM3LYH0yYXx98wAt71XQ3eJmN24M+HlamsLpGyS11wQjdKAPUoJYI0GBM4FoIhwc5HyLw49ADAAHZXdONPmsFKhRhpAVLWqAlucOZ+UitzaQ8oOF/6E3oL7bi2oB1ongumNf02CP663fjOdjMqtf4AgjOwDMthlP4OPJKGjYoOoefJHw/H6rp+iGGYYgALGIbZpuv6kvCVdF3/B4B/AMDEiRMzXj+2bHcD5m+qwdSKAtw0czAAYO4t09N6jK3Vbfjbwp04Y0wpZo8qDZbHdSF7Yy1h/DGEIryBUEU2ilyngEMtPgwsckclVwAR+hjXJ3UPvCMZVnJalGXDwCIXdtd78LvZwzBzeOf3FCVYHknBqr1NJrFKpUSwyvByipftoMmtWMmkjoCCJ7/cgSK3DRdP7msut75vEu07lA0y9NvZQ3H9jPR4flFydPa4Mlw3YyB6ZdvNzziDLN1+0hD4ZBWjy3PMzKJi+LsBodm05y4Zj6Mf/dr8P88y5nm08Sw4loGkkn6ocIn3TIKeO55jsf5gK+ZuqsGJw4pB5rx+WujJYPUAAOCv2gQA8OaQl/YIZzNOZ1cgsG9Vt41B17qXEOxvJLNwQwf0x6bs41DFlWHImbcHx0MJVgSJ8HRi59IPUSofRKVeiIXaUdiPspT2o6kaCvVmlDAteEh4Fe7qlWkeaerQjSygzjuxotfF+FngD9iTH7k8LttfhYHMIdh0f1BePEz9TlNkiIwCVWdgs9kj7QYAwNsIWeaRAjGSCMHSRRd4kVwLfAqZMACo75CwQ++D3VkTIeYTU0rRU5XSvmLB396E3kwDipjmTp85aPP5YUS804BDAKwun72NZRHXYRiGB5ADInYRdVtd1+m/dQA+Qnh9ajdi0fY6PLNwJ9YdbMHW6nb8e/l+rNzblLHjBcKMhqnAQ1ea+WkQm+MQImY9Mg06gx+ewaL9QdTUtQehUFQNflkDwxDixDAMzhxL3k976jswpKTz5BY9x15JNf0PgeC5TgYdBomIliWSVQ3NHgmf3zQd2x6ajZIYYgkBWYWq6Z36FakVy+76jqgy/eE4qm8efjm1H0aX58RfOUFQctQ7z4lJ/fPxwdpKPPDpZhxs8prlkSPKsnHC0GIUuG3mfXmgyYvPN5BsszWDVZrjQO88h/l/a/krwzCWTGP3VjTQ8krRoor6U+1tTAvBYhjmXwzD1DEMsykd++tB90No3AEA4EqIT8hUaSWeF59Br30fdcvxd6xdjI4/lmP1h3/rluMBQJ/qLzGJ2Yb+eSJG3f4Zyu7dAkd2vvm5zndPBksNEPIxR52CRdo4syQjWXi87bAZDU5ncCthb9uTtjFasXze2/j+oelYv+BN4uCZANblnoRrpVtxsPRktLsrsFIfjhYuP+K6P2/8GxbafoOihlUQ7SSDJYRlsHyGibIfNjBs9McYL9rRrjvg05Ov/WcMgsWIbnAmwUotEGswmqYL3Ta4ivsDALIC6bdBkDykDFFiO5eM0YDZL/2k+khWAxjMMMwAhmFEENGKT8PW+RTAZcbf5wP4Wie1RJ8CuIhhGBvDMAMADAawimEYF8MwWQDAMIwLwMkAfrR326Lt9XhqwQ6s3d9slgVtqWrDpkOtZvN6Kr0n0RBsiCf3VbBEsOsZrDG9c9Ii+54sOqJksH51zAA8ccFYLNvdiH8u2WOW2EbCHz7ehN+9vyGlc13T6kdjnLKzwxEmMRV5U/nxjDGEYM3bXGNeK1YMLHLjbxeNw29OGWr2YZ0/oXfMDGE00OxXdhSCtXZ/M8Y/tAA3vLUWdoGLqU5JhSnoPRSO+vYAjuqXh+mDC3HPacNijuuUkb3w0P+NMoVg0gF6XVHS8dn6Kry2bB98shrM0FmuPdFyH720eDf+/ssJeOHnR4Xsk17vdoHF6N45ET/rbrPha44biPvOGIHSXLtJEtMlFHK4IV1TSa8BeA5ECrcHRyDyPbsBALn9xwAAbNlG46O/e4whc765C1nwYdKG+4Bzb8n48VRFwd2+JyHaVHhzryILwx7OlfnTsHi/hHL3OByTycEY2Z0ipgWz2VVwNGoAKpLejae1Cdb5RFqWl26Im/6DCeoGYOkNOLD9XfS94dNO5y4cB7k+mKfpOCZ/COxGQ3k0U0gqSMEJdogOQhTC1e/8vg64APgZG2J1n3B5fTE68ApKsm1INp/Xhizs1UqgOQvB5PTFr6Xb4cguwDNJ7gcA1H3L8Rj/D7Tr0+DOPxMA4Nba4myVPGQP2afEdz4rj8qPoVTcD6XhXaBgTNqP/WNA13WFYZgbAcwHkWn/l67rmxmG+SOANbqufwrgFQBvGCIWTSAkDMZ674EIYigAbtB1XWUYpgTAR0awxgN4W9f1ed3+5QzQIFbkWbOvYtW+Jpzx7Hf47MZjcfbz3yHLLmD9/Sen5Xim0TAfmsHqisCDVQnxx0CHPzLBmjmcyF9PeGgBGj0Szh5fFlG4AQD+s/oAZFXHg2ePBMcmrtLhl1VMfXQhgMx4QWUSDANcPLlviP8a9U5q9yv455I9uPHEwSHb5LtE05R6azV5HrmiqDPGw+IdpK/xxUW78bvZnUkP9cFKRPWfXr+1bYGIHoQMw+D4IUWmJ1o8eAIKZj65GCLPYslvT0hom1i4a/YwNHtldAQUPPDpZuyuJ3FBgUs0JyVeX74fkqLh4il9OwmyjO+Ti2JLWeGDn23GthrSR/z6r6aY/XMUZgYrxQndVEEzoECw9FP+ifrLpYVg6bq+hGGY/unYVw+6H5IkobdaCTBA+eBxAADeSWabBLk91qZpHERmyEA01FbuRhmjog75KHZHTvPXF03BC2oOrnYmT3aSgiH2MJ3bhHO4pVhVfSGAM5PejbctrFFUzsw55VUy3iXqaCyvKce1ra3IyY09O0kl1Z0Ch4qOtbiX/wQFdSeAJA1Cwenkgc8JImwOksGyhZXmURPlABM7M2UzastTUVn7vOAyfLh/Fh7vNwYVzmws0CaiTI9ejhgLbO1GXMgvxko1D2LeNbhOugWqLYc076QRio9MiChCZ0+XMr0OA9kqbPd2z6RJd0HX9TkA5oQtu8/ytx/ABVG2fRjAw2HL9gAYm/6RpgY6EWHjWYSHIQ6RhaZnyGjYyGANLcnCRZP64CjDAykVFBsiBAu31aGuzR8SCHYHfjt7KK6aPiBqqZnXlGmPHhLxLAtZVZMuZ2r2pq48+mMj2y7g0XNHd1r+xAVjcdcHGzChX+QqBAp6Xhs8Empa/eiVE/zdE/FDq26N3Kcb3Af5d+XeJpz/4jI8c/F4lOU6Iq5rLQ2UVa0TSbaORNN0MAyijm9PfQdq2vyoafOnrX9pmqHm9/kGkrkCSG9ZrlM0J1beXX0Qh1p8OGFYMYaXZmH64EJ8u5MoKIaP4+ttQbGsjkDnzKzrR8pgWcFZ/PF+iuhpde4B9jUHcFHgORyd24zns8hLVHQZ/yrdY1bbrttRAuBZ/nLc1A3Hazy4DWUAGsRyRJOToMF5IMM9K6xCiFArm4dCrRWsnJpqYaAjrO8mikpfV8EbPWkvqmdhuTYSFyoC4lWij2qci17cHhRKhRC9O3EOPxcrm7MAXNNpXWpEzAk22B1ZWKMNgVe3YbrlhUyNi6U4BEvsAsGi5S0uGx/cT4qBrN5BXnaaqxgudzbmalMgyumfzQ+0GObg9s6EV2ZtgArIvsPHgLoH8WFmf3i2k+8PLftMK8GiJYJGBmvaoEIz+EsVY/vkmuIIrT652wlWll2ImJnaVdeOb3c2mH2J0WTaASOTJydfzvRjiHpkGudP6I1zxpdHlE6XVQ2vLt0LSdFMgvXFhuoQsvaXedvw+YYqzLl5etSMIRDMPEaDNTBfs7/ZPF4kRJNWP3d8OT78gbRtegIKpj66EO1+Bat/P8tUJwzHMwt34uN1pIc23eVtVkGPfJcIjmVQnGUDzzLm/c+xDJwijzeunILhf5gHn6zi3o83oVe2HfeeMcIYF1n34XNGYWRZTidC+2NlsD5dXwVF1XDqqNJgdvxHUBbtDnQbwTKkbq8GgL59+8ZZuwfdie017WhCNqSyYDZBdJGQ2aZ2TzAmyqSUYI5vBG7QdLARHtzphK+OmAd7nOGKzkHkSdU4lV2JorZ2AKMyNpaVWSfhv1UFmJrXjoEd+8CmmHkKtIc2vjMZIliCRggW7WtKpGdsSus8jBTWYb10GvyGdDqjRu5JsBIslhdwifZHSIqGbYpmBpSt7gqM9L+CsaVOvB3juCIHLBJvg8CogL4rsVoSAx5j1s9l42HTFdzMfQibwgI4KeF9mN/JSwgW6y6GjWfBMiRwllUtrX4gfNN28m9J53IahbMDMqAGujdb3IOuQbJksMJLaWgZn6zqCWUEEoGN51DoFtMuRnE4lgOtPdCCBz8jlml2gY1IGChSHb81sI9UmnY4o9UrY3+TB4VuW6fMULTvwTIMHpmzDQwDXDq1n7ncqiK4bFcDDjb5sKuuA+P7Rs+McjH6a4FgiSBF+ASEFVQeHAglRcHfVcO/vttrqvO1+2WTYDV7JAg8a5aYyhaCpukk49XVmOX15fvQEVBQlhM8zwUucvw5hlLo6c98i+pWv6kqSMcNAJ9vqEZJts0kWHS528ZjyiMLMbUiH/+x2Aw8fj5J0kcjkZnCHz/bjIYOCccOLkRFoQvHDCpAeZSs45GObiuI1nX9H7quT9R1fWJRUfoaA3vQdWw7RALzoRZFIIeRyXJomfeA0lQNbo2UIu5XC9HoyXxJhWb4MqlCdInv3i2r8aL4N0xq+DijY9khDMN/1Rmoyyaze4KS2jmvE3vjYfkSrNRIcM2oGcpgGZLnY21VOI1dAak5XLStMwTNkNt1ZIExCBYblWCRFxwviAAAu5E98lsyiV5ZhwcOKLbYZUsiz6OcaUA50wBNSe66eqDmBmy0XYlCz06IHHC78D6u0lMTfeElUpbHuwvBMAyutn2JO/j34O1IbwnuHHkCXlFORdaQYzt9prDkJaYEfsLmdj9BBEsEOeQ6BQwuDpZ/ChxjMcFND3G5eeZgrLn3JFx+zAAAxIh106FW0/soFTR7JBxoIsT+xygH+v1HG3HD22tR1RL6TMy1lAzGU5ALKp4lN9tOpc1HlGbH9Wk63LB8TyPOem4p7vtkc8LbcCwDu8BC14GLJvfFr6eT66jNIiBCe4riXQtUtGFilPLU8PMZi2BZTabpvaJqOvY3eYxlWggZpsIoflnF+IcWYNT984Pbh1VEpCMD848le/DYvO0hKq8FbjFkHXq6KL9q6AiEZOOs55Mup99V5EOzs9S03N7Nrt/meDgWP5vUF29dNdXs2fupoUem/X8c8+d8gHNWXogXhadxTFatudyZTR5oLj3zs911HRKOCryEP8sX4Q/8G2jan/jDPFXosiG9zkcvVWHjEIF0gfYn2Y2soaCmFsjU8OX4p3oG3mTPwvfaYNSxJWkboxWPiDfiF9Ld+D9uKV4QnwFf80PcbUQ1SLBYkQT60TJYVKmPek9l8ypy0AG/pY6cvoTscZqnGYaBZCTqpUByhNOheZDF+GCzuyDayZhtjAw9hZcp7VvjHSQ4vhKf4Cb+Y/ja0ye37ZdVvNM6Eo9ol6J82KROn6vGtd6TwTqy4LbzyHeJcIgcpg8uwoLbjzdn0jmLt006ywStWL67AWc8+x0enbM15X18sLbSLN/6McqBFm2vxxcbqjsF9NaerFjlgUAw05FsyV+WXcDCO2Zgzi3TfxQFxa4gaDKcXBBOyWpRlg2njS4FQIg6hWBK/8e+FmhSKNoZD988FmGrKHKbMu6UJLf6ZKzYQ57BBW5biBUBzWT5IpQdhvfhpaMMlI7deh0OLw31IKUqgjR7OPFPX0XcBxkT+Y4Pf7HF2O/hce3R51Q6KzcOV6SlBoBhmHcAzABQyDBMJYD7dV1/JR377kHmsOLbL3HCyl9DZFQgvy8qJgatXrJyCjHe/xICnBtbMjyOymYvAAYT2B04iVuLdVXnAaOOirtdl6AQgqUnQLBSMalNBmNaF6IXV40iG0nZiylmnmgJxtbsY3Fe3TjMyirB2WkbZRDr1QGo18pwrbAcUAHFFz8LY9PJ+bY53GANI2cuCsG6l7sdAW8rnsohs1r/VW9Gqb0elc0rgDxiI+CsXIp3hMdQ2zEV8SyKZAgAApACftg7az9EH7ORdbM73eA4DrLOQWBUKIoEQUyuh0SgBNMYgJ9xAHozAp6uC05Ut/rglVT4ZRWaDgwsdJqlY1ZoHDnvmtSTwTqS8PwlnZ+FNEDkWRYiz8IrqRkjWKbRcBcyT9bs2o+RwaLZk/Cyx1xnMEOQ7wrNFoRjeGkWCtziEVXi11VQH6tw/7B4cIocmjykj5WSWGuJICU1lc2x33W05DVaZmpM7xy88POjcP1bawHEdw0JmmaTFWn5bbFBBL/fH+xjpgSLfnerkmL4vZYOgkXvL5pRGtcnF38wyv0ufGk59jR0mH5t9Bq0Cyz8soaFdxyPmU8uDrlH6d/NxjbhEwifrDuE+ZtrcNbYMsweVdrl8ScKeq54jkFAUeGTVAgcm/Q1diQgXSqCF6djPz3oXiirX4XIqNhSdBpGXPcmYFHVsQkcOrgcyKqOgKJGDNjShYPNZEa9RieKRFJzZcaORfFtyaW4buck3NhvBI6Oso6ZwcowwZrd9gGGCNuxkiNiZjYttQxDVsM6nMGuB+eYiF0QQkrq0gm/MaOni27AD6j++H16doNg2Z1ZZmaK0yITrE36ADRqEkTDZFhmbIAOBPxBYsC1H8IUbgtWq73jHltiSOAkJ5nBEkF+d5uTjEMCDwEqJL8vaYK1ny2HrHlhdxO3+gDrAFQg4O16ieDl/1qN/U0ePDiFxXnsErjypkVc70DuJGyql1FoH9DlY/bgx8X7106Doumw8SzuOW04NE1PW6nP7e+uw7LdjXjs/DE4bkgRBL7rGTKryEymiGA0aJoe1QeLmt8Wum347KbOZbVWvHxZ56xwIthT34H7P92MshwHHjx7ZLeXZHUF0c5bPLiMDNZz3+wEY+jzWTNYFNGsOgBS/nfei8sAADOGRJaiKsm247TRpRhdnoONh1pjknevpEDRNFPcAeicTbH2ZlFPNJptU7RgnyPd7thBhZjYPy8tSoJ07DkOAYOK3SEmwU1eCQ0dEgrdNggcY9odCCwLP4Lfyfr9J/XPN2XuAXS67nbXdWDOxhoMLcnG7My1mIdA14NGzwLL4tVl+/DQ51tw+bT+eOCskd0ziG7ET48y9iAh+AMShrd+BzBAwcl3hpArgMwcZdkFNHkktPsV2NyZeykUbHwF88X3YGeQe2NWAAAgAElEQVQMItMav6enq/CoHFqQBc4RvQeLF7sngyVQolE8AhP9L8KVlY3FKexneM3HuEz8HO/hdszBOOiBzAiU3K69Cj/Pg7URCXXazxYLdt0PMIDdnQ3GkYM9Wi80MpElfmkwZpY+GUqBsoVgaYasP83KxIIEQrAkf3KZG1GXAQawOSjRI5kwOeBPaj8A8JhwA/a0evBVCZmRlDgnoAKSt2teWJKsoLh+GWS9APVrVuFJ8T2sUTqACLnLPb1m4/mtg3GHc0hSx1i2qwH/WX0Q0wcX4oKJfbo03h50DWv2NeGSf67EuL65eO8aMjV0YZp/kwaPhJo2v5k1ENg0+GCpwckeV5xep3TDIynQdeLFFF6iR7MrrT4pbSIh4dhe025Kad960mCU5hw5Df20RDDZ7ILDCPjfWxOcLG3zK53PcYyUU9CPjcUtszrbeVhxwtAiDCp2m4Q5EpbsqEdtWwCnjCxBn3zy7rISPEnRQkoEKbkMhEwO6BB5xszC3DxzcCd/qVRByd2I0mx8eP00U8UTgClq8caVk0PKBqkKH+VV1gzWv381GZ+tr8JN75AS/nCC5TRl2rtPRdBqpsyyjJkV7JFp78FPChtXfIlJTBuq2V4oHRS5HO9+5p/oI+6Gr6YvMKizF0a6YGvehaFsJXZwQwC1DpynJmPHoqAPzVizibRXiI+SaUkXRJ1kVrJz89EAH/xSarelIJFgvR9TjZ32p7C9aQiA1ekaJgBAlgK4gpsLVWew0nYlWRiHyOmaima4EdADcDvdkEsn4kTpKYwrycWMCOvfpv8bKq9D1E8AIJjy4oo/mNmjJso6nwDBYm2AFkrQ4kLXYWPIDKbNRo5BSg0BWUqeYNH+Exp4KAYxlBMor4yF+pqDeEN8FI16FnZrZQAL8KWRZwJpiYgvyczm9tp2fLq+CjkOoYdg/Qg454WlqG31491rjiY9haqWku1Aogj6YFGj4dR6j6yg47371GEY2ye2Z166QUu9IsmB2wUOTpGDyJNSK0ecns54/kiRQGXvgSNPst1jsapIBgUuEYVuEQ0dZHLyvjNGYGyfXOh6qJBrrLNBM17ZUbzLAGBnbTu+3FKL0b1zcfvJQ2OOiZIna+8PnTQ41OLD01/tMP8/ujwHUytItYFVdEvRNIhg8fTPxqHdr6BfgTPmMZMBJRkcx+CWd37Awm11eOWyiZg5vCSqXxQt/7vp7bUY0zunU1+TNfMYHutQ8+dEVIDTBdlSHmj9N1nhmCMFPQTrfxS+9UQZr6ZsFkqjvCyGYD+Gs7uwq6UGQOYIlsNLMlaNBeOBuh1w+mrjbNF1TK9+DacJq4CW2wBEtg0wM1h659KGdMKuEwKXk5MD4JAx45r8bKppCu3uRf6vp58Y+n0eCAD8sAE2kv1jpNgEK6AC0wLPQeRY7OB508A0WnnIz5n5sPEKFPrwZY3GZIsZtW5I0OtCfIK1wHYypPZ6nMQnHtipsh8cgIAumOpLDUwBZI0BlBSuB8kDBgycxktO4UlWTPV3jWA1Ve9FOYACph0FDJFoL6gYF3HdPK0FE5ltcLYzADrLuEcDDXRizQ73IHOoafWjutUPlg0qBq472IL7P9mEB88ehXmbqlHfIeH00aVx+4gSAfX9oz6AQZXCrpcI2tJkypoMggQrcrjz1IXj8MfPNuOJL7ebPS+RcN6Ly/D9/mZ8cN00TEjCdJlmYoDuL4/sKmgWxxWHeIbjlctJOeXkh79CXXsAp40uDTEZppjUP3r2h/bN1bcHsLO2HYNLOlebbKluw+Pzt+OssWU4aURsUSfTT85CQqwTFYqq4fJp/TFzWDFGleeYWS7VQoopQaCfrdjTiDafjGmDCpMuowxHjkMAz7HgWQYNBqmjPYLxDHk3VbVhx59ONf+v6zra/EoImZ09qlfINpQ0x/IOSzfsAotdD59qZtoE9vCzbkgnegjW/yAUVcPXzYVwa4NQNOn8qOsFODegAJKnJaPjyZFIxspWMQ2oexfZcl2cLbqOUt9OHMVtxFo1RolWySiM97+E0sI8zMngWGwgRMjlysaL4jPIRwt8HdPgzEr8JQ4AdpUE63wuEYewaclnWuIh4OtAFgA/YwNrIySBiWOMTFWYnIYSFe3nCyidH+yqqsHGkJc6Z8i0Kxx5MWuSpYeKeoUJ8WcQ52edg7XNLThaTNweQlKBR+XLYON0/N54S93gehJ7Gjz4ylGW8H4oluhXQLQr8LNVAET4xHzU6HnwK117sXjq9nVa1mvg2IjrDmn6Bu/bHsbKqrMAnJbwMcqq5uMOfg16yxcCiD1L3IP0wxoY8hZfoHfXHMSDZ4/CMwt3YUt1G8b3yU0LwaKEgM54p8O/ivZdMAzT7V5QAsdg1vDiqKV5bT4ZVa3+EBGGSKBDTtZY1toL2xWhkB8Dd5w8BL+Y2i9lnyJv2LOfQuRYSKqGAYWuqNtaf4+b3vkB8249rtM6lHDUtPqxs7Yd5XmOqHL7lNx++MMhXDqtP8b1yQ0hvLKqY1R5DkaV54Qew1LGGD5B8PuPNmJ3vQcLbjsuIgFMBsvunml+l/UHScxVaMi0U4+ts59finyXiHm3TA8x6w6/m7ySirEPfmn+f2hJFsaFZY7peerODBbDMOA5BrT60cxgHWETD4nip6+T2INOWF/Zgtd803FH9pPoPWZG1PVkniieyRkkWKqqoUQjhKrP2BOxSyvDTi35ADZZcAb54MToLw5RtKMZ2WhVuh60RIWuw2EIQDicbkxkt2MKuw3e9uTPucMwhXYUEOEHEenPYAW8hEwFGBtq+5+No/wv4T+FN8XcxmsEGDR74/TVYJPtV3ij4+pO68oyGbOsc2CMvkCNo/LiQSLHKIRsMWJ8gkUDRetMcjwEdA6vq6fgPe5McxltZE62PEuRJYiMAlVnzHLDhf3vxNTA89hWMCupfXXad/NBAEClYHjNsDkQ7JGDFs5BavdZObnevIrGxbiJ/xhl0t4ujLQHqcL0wRJYM5sEBBXRqAhFPMnrREFL2uh9M7DIjU9uOAbPXDw+5X1efdxAFLhE3P/pZszZWI3vdjZg5pOLzECSYkdte9rFeSqK3Hj5skl46P8id/J7jR4UZ5wsTapqitbnTiZLOzOB0hwHxvXJTcmMVtd1s7/n8/XVuO+TTdhVRyYBZVMFMzrRtvpmRVMRpD/Fqn1NOOnpJVh3MPp700qm6DU2pFcWzhpL4g16/1S1+PDe6oP4ZhuJSyiJqyh0mffEI3O24jf/XW9m99OZgeEt93iBm5x3yyI0WUoW7zyZ9NOW5zmgaTokRYOu6yGlqGU59oi/H/UF684MVjg401vuyJp4SBQ9BOt/EEt3NQIApg8ujFmGpgiEYCm+rktJR0N9zUHYGRktyEJhrz44XXsKlwfuNEsTMgXekAiPRbBsQnoDl0iQJT/8EBHQBQiiCB9DxuNPQb7bYXiWZRUQyVV7BkoEJUMxUGJssLuy0YRstCmxAxOlahNW267FX5U/AQBEux1uxg+H3lnVTzL6m2RLcn1l4fm4QboZVdnB0reD4kB8rk6FL3tg3DFX6Acxg10Hra0q/hc0EIhQ0iSmGMh6PSSo8MEOxgjSqK9Ml69zQxCmpv/ZqDrzbaiXRc+18k7DZy1JI2va2ye4k8uo9iA9CMlgWcqbaHAi0hK+NAXvATn02neIHMb2ycWg4iQ8DsIwoNCFYwcXAiD9Fre9tw676z246B8rzHW+3VmPk59eggv/vrwLo08eD3xGjEi+29UQcz0+xVLJIzmDlSpeXLQb4x9aAF0n19HX22rx+vL92FPvga7rGFRErqUt1cEKkk2HWnH162twoJG8x9p8wWdjtNOmhX0Qq5UntByQbJdtF3DMoAJjmYaPfziEm975Ab/9YANeW7bPOHao9xQAzN1Ujf9+X2kSq3T2EAmWLDUtzbxoUl/cNisoTkQzWrRPLNchYMT98zDk3rnwyao5nnyXiIfPHY2TR5ZgT33oxFpRlg1HVxRgZFmo11YmUdvmx9nPL8X1b30PIHVvuSMFPSWC/4NQN36I0YwT0yoilxJRaCK58VRf15TOYqGjkQS9zWw+chkGpTl27Gv0oqbV36UXejxQZUDeFoNgqR68LjwKTRYBdC3TEA0+nceYwKtw2zhsYhj4WaIuF/Akf84FkNk0dx6RtLVDgqbp5sM4HaBCETJrN9XA4pUYSN5W9GPa0MiQF6doJ1knm95ZnVEOGBksJtjvU5s3Hl9oeZjABaV6v3PPxsfyGDxdHvsaBoCz2t/BZHEh1lYXAhgTd30AkNobcT63GAxbBPrb39P+CAbbNqC26lWgz0kJ7QcAAl7yYvMzNtAr2pmm+nebl9w/toK+KJtwesx1RdPIOrkMlk0hBNHmTo9aVg8Sh1XWWDT6MyhowJeOEj4rrpo+AC1eOcSENx2wehDRbJFVcGXuJlIqvqEyvRN6rT4Zfpn4McUSNaKCDtGQajBozToeaaVQj83bhlafjJtnDkZJduLWFD5ZNT2bKorcyLZTtUYZDMNgxtAi7KzrwIo9jRjTm5SunfviMkiKhtr2AD654RgMKnbjlJElmL+5thORolDDMlvRMl1A6P1hJcnW++f97ytNLyw6+UV/7511HWj1kfuCLnMIHFp9cpfvvYCi4sQnFsMusFh4xwzcdeow5DtFcwL8wklEXOhfS/ei1SebqoLms4Gn5cMaFE03iTzPMnj/+0p8saEaz1w8HhVFwZhqWK9svHP11C6NO1l4AgrWH2xBq5fEAOP75uK5S8YfUcqayaAng/U/Bp/Ph6ubn8RntntxdHHsh71uiBjAnzmC1aK78JxyNr51nQyA+Fq44EN9U1PGjgkEBSB4W/QSM5FncRy3EZP0zRkbh99UlyMBt8ySB00q8t3HqH/HaP/LsGUXmaa4gUB6s1gBFdillaGB74W8QCX+LfwZVzQ8EXMb2UcCepklL2ibQbBEdO55UIwSQQWd1Y+swZipypeAp4zG0h6uxP3FtOYDeEL4O66R3zKXueFBAdMOLZBcBshveF35mWCAMqphLlbZrsdxe59Oal/hcAdIGYurKLJQixU2Nwlk7Gpy43cYvX2OnIIkR9eDriJgyV6xLIM8l4hrjydZWzODlQafKiuuml6BO08ZajbBt/ll3P3hRjz0eeqW82+s2I8P1hLJbkXTMcToVyl0B0uX9HgusSnizRX7MeWRhXj6qx0RP79gAimpvmRK7HuIN8uZNGyvaU+4d+XGEwdj1T0zseyuEzG6d078DQ4jfLq+Cm+tPJB02SYl0FcfV4G5t0w3lQBpSR0fYVLAFqaAN6o8B3edSozlo5cIhi4PJ1xWnD661PwN6b2y6VArHp27DQAhK9bqBOqDZT1GXZs/ZHtTFbaL956q6TjU4kNVC9n/tccPNEmVFXQsdNL0P6tIiXh9e8B8HmiaHuLvRUVrEnlXZhqmuIXxW5fmOHDGmLKkRGOOJPQQrP8x7Fj7DVxMAPu5vsgpif1C6cgbjg/VY3FQrMjYeBq4Ijyh/AzfFV0EALjV+ww226+EuP3zjB0TCHpPCbboTbaikd0SIWfs5R9OFGRDXU5OIWvYofBohxMiz+GP7HW4SboRvjTX/Ddkj8As6Qm8WHwfXLyO47kNGC7HJqCK4ZMlcwaxEkSoOgOBUaGGKfLJio5tWh8cYIN9eP39W3E19xkKG1aZy9y+SvRlauFk4wc5Gm8QLDlx0Q/FMCVWmGD/nWpk1dQk9gMAEiWYFoJl44BipgU2qTmpfYXjSvUuzA78GXkVE+OuazdK/BxJGlm7NPL7uXIKkx9gD7oEhgFunTUY180gpMpt43Hp0f0ABAN+GqxkqpRZUjS8s+oAPvohdX/CuRurzb8VVTMzGr+dHRRNOW00KW0e2kWxgHBQFcHsCDLtAPCnc0bhv9cejetnxC43pud57YEWnPLXJbjk5ZUJj6E4246yXIcp8HOkIFUfrHAJcEqw2vwKZFXDliryfrNOClx+TH8AwIlDg5UKNGEbrURQYNmQTGus93TfAidmDSdKgzTQ31nXjvp2EgtcOrVfyHg6jOtmSEmWqRBICSH9l07+dbX005pxioQfDjRj/uYa81qmq31t9In1L3BZJgCCPVgcy+CrrWSd8AkBXdfR7pdN0tgdoGWa4X50P1X0lAgergg3jEgT2rd8BQCoK5yKfnHWbe49E3evKsbPnH1wXtpHQkDrrOkDmDXKSDQlszf9CnY8tkhlGO2KPnPCCzZoBhGQZAWimH6ZarV2CxaKd+CgPBjACSYJSdYfSVE1aDp58PIci6/EE1Ht8+MuNb3XkJlxE1jY3GQ21qZ17qUKGZuPZEwUnnw3hmURgAgnApD8XjjcwVldv70Qs6W/oCLbha+NZQM61uIi4R0sa2ABXAIAuLrhL3jKtgVb2t4DEMebySBYkGOPM2TMhmKhwgYJlmb8nQxRI4clv6XEBgkWbyelGpycHNmxot0vo8pvQ7MwALm58SXoXYYqpVNP4pi6jizdAzBAVm7iKow9SA9sPIdbZ4UaQ3Msg9HlOSgwFMbENPYxqJqOBVtq4BR5HDeE/N7BEqquy7QDJAAsybZhSIkbec7g/UWzHuGKc10FzURkR5Fpt/FcTLlwiosn98WxgwvNEsZwgY6fIjzG8z5ZCXKqUEcnECkJavPJaPHKWLyjHkDoNRUUESHLNlS2YOMhcq6jZbAunNQHF07qgytfW42F2+oQ7xIN76OTDRXX8yf0xpSKgpDxUDIj8iz6Fzqx6VCbOTa6Hr1mu5o9plLwHBf5ff23hTuxaHu9+X+arRpdnoPlexrxq2MH4LZ315F9abo5TqtgRjgJDCgaRj/wJRgGuOMk8oy58cTYhs5dhWyWO5NxVbX48PG6QyjJsuM8I5P8U0IPwToMceiLx1D4/VNQfrUQrt6RTUNTRUHtMgCAY+jMuOtS35D2QAZ9oBp24jh2PfoYs/s6R0pG9CSD2GTxF1yORlnC6tzS6CsxDAIQ4ICEQMALUUx/eYfibcFQthqSTgLkyqwxqG71wcklly0IeNvxgXg/2hk3gNODprJpVgjyWcoNnC4yZidiExdaUqdZTIElRohIsGRLTTkFY0ixs0rwOIKhAhlNMc8KnRKsJEoEKcFSrQSLI3+rcnJlly2OPrhNug7lBb1MkXPeSfobBTV1glXdSs5Baa49Ic80V04hZgf+jA44sCTB3jy/34dKvQgOSChzZq4nsgedEckLT1E1fLuzAZdN64/zjYDkmYvH47lLxiftmxcJHknBtW+uRZaNx8YHTwGQJh8sy7aKquO3s4fh1llDsKO2HT8caMb4vnnIcQiYWpFvlg+mC7GMhpMBFenQ9QN4B8BFEUq4IuF372/Au2sOQuRZvPPrqUdMOZRsGFpzLJO0fxklHh/9cAg+ScXM4SQr1eqTQwQhrCWC9N1C31kvLtqNuZtqcPVxFThnfHnM49FrP1YP1ldbarG1ug0zhhZhaC9yjQXC3jeyxTajQ1LMHmY+zK+JTmY8e/F48CyDnC56BMbLYNGeq4n98nD8kCJz0sNKGK0ZrOJsO569eDycIocr/70GADqZItt4FhxLbBOe+HIHRJ7NOMEyv6cx/qoWHx6btx0T+uX1EKweZB6Kpxnlqx8GAGz89kNMvDh9BKuu9hCGyNsggUPFpJPjrp/FqxjIHEJWuwfAhLSNw4o+hz7H6+IrWNH6awAzu41g0ZpyanobDTJDCJbs9wFZ6SdYVDRCMbIbG8ouxKt7J+Ne9/Ak9+PFBHYnmkFeHCfrS6FxByG3DgWKB6VtvOW738VW25/xfcPZcLpfBAC44IeuqaasejhoNpL+tgDwd/ZieAISbmBEWM+qtXacgkqxM2qQYIkGwRId8QkWqBlxEllRVaYEKzhmM4OldBbniIVWNhcfadMxKztohCnYKcFKPKvWab97VuM14S+oYScCmBF3fY7ncUAYAK+kwiMpCQWcbTKLWdITKHSLWJOBjHoPImPBllrc9cEGPHHBWMiqhlyniMkD8qFoOu7873qIHGsSrHR6StHnos3yXEyH0hfNYF1xTH8zM/bdrnr86rU1mDIgH+9eczR21XVA5DkM65VeVTOawYpmNJwsOowJx0SzOrXt5LkjKRpqWpN7r2maDoZBWshzsvBYTIaTPb7Tcm40XUdpjgODi93IdQoh15E1s/nS4t0AgM83VOPeM0aYMu3TBxdieGnsa+K3s4fi6uMqMDiGMNbiHfXYXe/BpUf3N68xqrz5zqoDmDawwJSPBwip8UgKqlv9pvw77bUa1ycXAVVDSbY9LfcflYKPti86GXbV9IoQw2AqxFHT6jezX6qqI9su4ExDfn7OzdOxtbqtU5aWYRjYedbMUlKJ90xea/R800kbU6b9CBN/SRQ9BOsww+bPn8VYAMvUEdje9xeI31mROHZ++wGKGR1bHeMxKit+SUSRbx8W2n6DPfUVAC5M40iCYAKkBIBxkDBb542ANsMlgqVKJXzgYY8zMyeBBKFUPjzdUA3Zc4UjJIC+tOMpWoVDNuXNyXjPDXyCIcJ2bGm+AED6CJYueeBgJPAMA0EQ4NVtcDIBBHwdsLsiE9Bq90j8VTkXxblH42hj2Rf203HA68WVCFWmEqq/x3bbpdjZNhzAdwAAzhAi4SzXhGiIlIgJZLAYwThGEteUZpxPlQtmsHTjb11JLoNlGi1bfHZsLkKEbUn2Q1khVW/DDG491uuJq/tl2Xl4JRUdgcQIVovRlJ5uRbkexMavXyezzle8thoAMLjYjQW3H5/xfqugRHvwWrXOjKcagNFA+udT+pnqsNTQdXNVGzRNx/5GL5bsqMewXunNYLWlKYP1/f4mbK1ux+p9pG9S0XSs2NNoSmVHQ0C2lkcm/rupmo7T/vYtirNteOPKKakNugugwXuy5YEA0L/AiV7ZdtS0+eGy8Th2cCEW3H48AITIhVsJxbGDCvHdrgbcbng7me0DMX63t1cewAuLduHiyX1xwwmx33ORqiPofaTrwKtL9yHLLiDXKeD9a6dhYJELDMNgo0XVkmZg3rv2aKQTZkkfGzke4aJk6H44QIjf4/O344GzRsInq8hzhZ6vEWXZGBFFit0TVuGiaHqI6mW6UZRlwwUTeptqhubkzU/UvqCHYB1GkCU/Sre9BgD4h3o6piRhjJoIdlXWYLjuhjRwdkLrO7MM1TEtOdWxZMAZBIt1GmUTRjlXskFsMlBkCV+Jd0DTGTDspTHXXcZPBgLtGKtlpilTCZAAWzG+dw4noT9TDabDDSDxdL1JsAwhBpmzAwqgJKl4F/9AJOOiG1khL+OAEwF42lujEqxD7lH4qyLg2oJgEzktOQmEiXCocgA2RgEHy0yiIUTCWbI9NsNE2eaIX7a2v8/Z+O2mPji5eCgmx12bQDPKADVLBmtn7nR8V2vDoCSzi2LDZlzBzUUveTIAYtZqMzypbBG8wBKF2mKosmUlbsx9C95BrnAA/oZBQM7QuOu3ekm2rodg/bigQaE1IJ391yWYd+txePnbPfhw7SFcNX0Azj2qa2U2AaVzZp9hGAgcA1nVIas6RD75ACzcV+4XL6/Eqn1EKbYjoGB/k9c05E13WXO6Mlifra82vZEA4LVl+/D2qgPYcP/JMeXfqXEzkJyUfl27H9tr27G9Nrl+3HTiqL65ptltMuhX4MINJwzEHz7Z3MnAmQbTA4tc+MMZI8zl9JrLNQUxyO/22PxtGFmWg3tO6/zcbfPLqGz2oc0Xv42BkqlF2+twdEUB+he6QrzjZFXDpzce22k7qzJheJnsy9/uwdJdDbhqegWOGZS6CJDbxuOGEwbCbYv8nKX3/RcbqsGxDE4Z2Svkc4aBmbECSOndp+urUJ7rCFkeD5KihVSPpBuDS7Lw+AVBaxVa4vhT9cH635DyOEKw8et3Uaw3YrvWG4u0cQnLwCaCVq+Mh+qOxVT5JQw46ZqEtnFkk5lxp545giXI5OUhGmITjEE0mAxmsPx+Qmr8EE3j12h41nkjbpZvgl/ITN28TvuTjAzWqMb5WGS7A0cf+GdS+5Gp6p2RwaIlh4o/3QTLyLgYBGspPxkfq9MQ6/1mGqVaZg6n6utwPrcYSltdyLqqUX5n7X3iDYLFq8Frgpoo213xCRbnyEOlXoRWLbokfzh2lp6Jof7X8HH5neayfQXT8Yx6LqqdwxLeDwDk1a3E/cIbGNu+xFxmzy3G35Rz8DrOSGpfVrDtRNWNzUk8qJ6srcNp3Cr4m6vjrwxA2DUfW2xX4A7PUymNsQepgZZEDSgk174YIdNOZ7Pr2gPYUt2GuvauT0r5I2SwAGBM71yM7ZMbs8clFvrkk+fFu6sPYs2+JgQUNaQ8rMkjYV8jeVa9sWJ/SseIhkfPHY2XfjEBffITv/8jwdofQ2f5JUUzfZMaOgJo8XYuH/bLoUF8orD2A/0Y6J3nxIfXH4N/XppaHQ3NjoQrEEYqAyfLQyW8KWlauqsRH3xfGfEYtLTuk3VVeODTzdhQGV14hO5//uZafLW1FkBQXMv6eTgoITx2UCFmDC2GruvwSSoUVcPW6nZ8s70eh1pSnygDgFyniN+cMsxUCw0HLRH8YmM1rn9rbafPHWEkdl+jB3+euw1vxrmXzh5XFvJsSZfVQ6Iwe9vSaNQcDc0eCYu212HNvsxaAFnRQ7AOIwSqic+IkwngK/E3mLT3hbTte+G2WiiajokDipCXk1iNuzubkAq37iU59AzAphC5VtEwMa0rORa3SddhbW7iRq7JImCo2gUsEtxRxyfQTEt6Z1UpqDeTRoUcDHU5Vk6OGFFRBtkgJqohKKFK6SVYjJHBosITL7pvwq3yjWjjoqvY5bTtwEz2exRKQZnnS/z/wRPC38E07QxZN5g5Cr74eIcL7boDAYM8aqoKO0NevvYESgTtxsvHn8RvGFB1BCCG+KTRF5GUrPS98VvqQnBfTncOnlYuwL+k+L2Q0b6ck8UAACAASURBVGAPNAIA2OxecdYMQuLI+ZK8iZm5yp4mOJmAqfrUg+5BRRH5naZWkOdiJJEB+kimKoJyGiwZImWwAOCD66bhkxuOiZmpiYX/XH00fjd7GJ77ZhcWbKmFZASz1nsqU1YYE/rlY/aoXimVullBG/N/c8pQ7Hz4NFx9HLEvWbClFm1+Gac8vQTnvrCs0/cIWDykkuk1yVQZaHdAVjXMM4yjnSKHjZWtGHLvXJz9/FIzW8GHPVOW7CQqef9evg+6rpulnUB08Qp6rmva/Hht2T7sqotuoh6arSLbXTatPxbcdpw5Zoo/fb4Fs/+6BCv2NJomx5RUN3tlDL9vHiY+/JW5zC+reHTu1pgEryuwnirOUqJ7p1FOeeaYMszZWI1/L9uHho5A1HMcjqcuHIfv752FoiySpUz63ZYkWrwStlS1obqVxBFm+XE3ZLA2V7Xh8ldX48kvI/vhZQI9BOswQodfQovugo/PxSC2Ci5/YrPMiWDDlm3IRgdOGl4cf2UDTocDfl0Az2iQ/dEfXF2BQyX7tRvZMl/uEHykTcc+YUiszboE2chgSYhPsIrRggFMtSlGkW5UOQbjX8psVOUcBQDgHYT88kqyBMvoGTJKBDXO8H4KpN7jEwkMVfITCYGjs5MeKXq2dUTtp3hFfBKDm4MZHJqhUgOhmUqdEiwmSLC08skYHXgFv3fcB4CUG50XuB9XqL8Hy8UP+Io6tuNF4WmcUvevuOtSBHtRgo/IIqkKJ7OrkdW2M9pmkWGQaEYIqihSBSfJUOpKBVSBkF4zCQ2FJwRe9iRGsFQvmZ1XbUeWQeqRDhvPIsvOW8yEO1/nNCRJh4w6Bc22pEqkYoEGo4qmm8EuJT2SYTNxOCNcTfF0w7fri43V+OSHQ2j0SNjT4MGO2tB3pdWkN5kSQUp2092TligkRUt5YjGgaKYwhEsk17GkaAjIKoaUZOGuU4dh06E2/OHjTeY2lENtr2mHV1LN7BQQ3QcrfHmsa0gOUbK0yMNb7p8Zj3+DY/78NXbXd2BbDfHICgpQsCHb8ixrEpgP1x7C3xfvwVnPLU1poqDNL2PR9jr8cCCyL+KDZ43Ckt+cAACwFt1YJypeWrwb93+6GYeafeaYo/V0UXAsgyy7gEK3DcVZtphGzenAwq11OO2Zb/HYvO3muLPsfNI+a6mgW1Sxw9BDsA4jvGm7GOMC/8TSkp8D6JpHTjjOPfAnbLBfjcnaDwlvwzAMOhgy6+5p65ohajQ4NfIycmSTRuFMZ4wAQDJIh8TEry3/Tftf8I3tDog1iZ+3ZLDHNQ5/VC7FwV6zAACCESyLScp3+/lsfKAei/U2Us5BJdG1JKTJEwFr9EGxhrJfCe/BQOYQ/O3Rrw9GJWUzDB8ktLSEUQ0bHy0R1LggwTIl541AxStr+F4finXCuITG7FLbcSq3GoN8GxJaHwAGHngP74sP4Kjmueayoc3f4B/i0xhWm5wJNkPvYzGYbWMYBjPFzTiDXQ6fNzXyLhglk7wj8QBMNQiW6k+MYMFHgiTdFt9nqwfpw6PnjsYj54w2VefECH0RNJATjJ6oQBoI1uQB+Vhz7yw8c/H4TsdS1K5lmayKYeE+QpKiIZE967oOv6yGkJZY8EoKHpmzFf9csielMVth+jQZQe2Y3jnoV+BEfXsgxKNo2e6GkO0um9YfWXYeE/vloSzXgUTBMgyGlmSZZaLdjU/WHcLQe+fhzv+uT3pbh4WgTx6Qb/btyaoGh8hhoCFyQDMZkbZfec9MzLt1OoDoGSw1jFFpMRiWVUpdtqwnWPqAKpt9ONTiM/3ZOgKKeYyvttZi4dZac1uBY4LljP5g0L6hMsFnqwX7Gjy4/NXVuO+TzVHHTsUrrBksa7klZxGjCS5PrPJg7i3Tser3s1Cak/j1mQqCYh5kXGW5Dmx84BTMvWV6Ro8LABsMT7X6NJRSJ4oegnUYgT5sCvJJNofvgkdOOLJl8gLIKuqb1HZehjzcvRkiWGerj+H4wFPIKiR9JLmBalzBzcXwlkUZOR4ASEYGS0mgRJAazaoZko33GZkf+kISDaGIZAlWm6s/7pCvxyd5RLRD453o0O1pr6le7pqFh+Sfw1s4BgDwq9bnsND2G7gOLoq6DSVY4IOEVo1yXjVD3ES3lAjS+nIaVFm9uBIBLfPjtcR/Q7e3EhPZHchRg/XaJkFUk5NpZxXyW7K20EDpT3gBz4nPwtdam9T+KDZww7BQHQ/eIv8eD6pIAhvNl1gQwPgJwWKcPQSrO6HrwE3v/ICvtpIeRats+iuXkUmUkmwySREsEez67LPAsSh021AYJmxw/OOLMOj3c3GwKfleE03TMeTeuXjwM1ICbw0AHzt/DL797QmYPrgQo8vjZ2Kf/XoXhv1hHp77eldCx27ySPjHkj14denepMcdDpqteO6bXTjl6SWobPbhLENAoMAt4qH/GwUAWL67MWS7a44fiI0PnIL3r5sWIrEdjnDyOrw0G7efPASnji7ttt6Yuz/ciCfmk+wC7QFP9DlrBccyZpnpoGK3JcsaWromWTJ6l0/rDwDom+8EyzIoybaj3CCk0YhT+DmL1SP41IXjzJI6moW656ONOPYv3wAgQhG034qSMU9AQb4rGCc0dAQsUuOspV8sWMHx3pqDUccQDUocmXYAoG1KVv/Cr43nw8bKVpN4EaPhxDJY3Q36ewtJ+qqlA4/N2wYAqG0zYowMZ+uAHoJ1WKHaaJQsLiRqNMkG2dGg6zoKNPLQzy/tn9S2j7vuxBmBP6FZTLzPI1FIioZq2YlKphROO3mh53n24H7hDRzdOiftx6NQDIIls/EJFvU+UjMk057VthOTmG3IAwl4bUY2QtSSC2RMIQnjgb984K0YFfgX1hSfn8bRAmuFo/CKejrUAqJAp/KEvKi+tqjbMBqZ3WN5q+Q5+b01KfR71meNxAPypVifd4q5zK558LV4O96WbwEAyC2HcD//b/wCiWWSeDsZo6AlMXNFVSz5oIw8Y4yZ1ZIjWJxRVsmFESw/S4KHQILleuF4jv0FrpR/A7E48XJa3UaCWM2fmDIZVfnknEeGOepPBXaBM7M7C+84Hn88K+iHSIMwWtqUzhLBaKDHTKUZPbwMVjHUCAGgT54TffKdsAscLj26P4DIgh4UC7eRgDI8SxQNNPDtqkQ7EJoN2F7bDoFjcfa4MjAMMdCdYfh7rdzb1CmzEgl/X7wb5724DD5JxcEmL456aAGe/yaUON753nrc/M4P5qRSJtHilfDOqgN47ptd0HU9qkhFonCJZDuvpIb02m2tDpYGWvuipg0kVSxWtUd63UU7nZMG5OO6GQPR1xAwiVfixofJgvuN7/jkBWPx9R0zAJDfWbSsN6WiABdPJhPTsqoHszAcY2ZiGj3Bd8uUOLL9kRAs6YtMsN5YsR+XvroKQCgJe+mXE3D5tP744/+NNJerlgmMeD1Y3Q1KbCNl5DMJVdNNw3GAxMQnPb0EYx/8EvsaMifi1iPTfpigvbUJq/EL7LWVQcj/O4Dkg+xoaG1pRi7jg08X4c5JTkq01j0Cmxqa0Kak/1KhafVsO296q3BGbw+XTDCcJFrdFbhY+j0GFhTiT3HWVSkRyFAG65iaN3CzbQFWNtsBHAW7m2SwHHpy5FrztmAwU4lC45YOz/qkC7RHg85qagIhDVogesBOCQljIStalPPa6OiP19TZ+GVuP3OZw+5ABVuDgE6CJLWlGlfw87FTSczfSzCEMIQkiBGjkuvP9NACwAg247PkCJai6QjoPFhbqOJhgHUAGhDwpibD7DWCg3AFqVjwZfXHMnUEGtjEngOCTIgz704+aOhB6vj5yyvM31dg2RCp7CElWXjknNHolUOWDe2VhUum9MXE/l0nwQu31uKNFfsxc3gJfjk1eA+G9x8lg3ArBkXTcftJQ9Dqk5FnyQ7wCZiOrjf6etYnWIZFJdqzHV1/f111bAV+Pb0CI+6bD5+swm3n0SvHjlX3BEUChvXKQmmOHa0+GfkuEaqm45ttdWBZYHR5LuwCa5K9R+eSGfWF22qxam8Tmr0yHp+/3fRz0nU9xDw207B6EbX5FTOD5bal1o/X6CHPyYPNXpMAyaqGymYfKpsN1VsLYbdmuera/Ljrw40ocIkYUZodksG1YvrgIkwfXIQ2n4y3Vh6I28dHrzF6HdOyWpFnI5bbqZZyQICWtxrLWBaDS9yYOawYRw8swLg+uSjJtqekVknLTqNlsHbWtpvXPmspERxQ6MIDxuQLJVOqpoNlGGTZ+E4S+dHw69fX4IcDLXjlsokY2ydz1Qom8TO+p09ScfJfF0NgWXx954yMHbcqTOUxoGho9kho9ckZ7f/qIViHCRqr9qA/I8PFyGCMMjFbmghWU80+5AJo5ArQO0mTSLMx0J/+xkBP3T78W/gz6th+AIiaGm8jBItPMkuQDLyMC8u1kRBdRXHXpT5ImSJY4dkNR24Jfi7dDUXIxrtJ7Cfv0NdYYLsLq5tmATgl2LeUZk+Z0R3foYhtglMbCaAQulFypsfw22JVcu1wlgyWRv3O5NBrPJIZpCDaoekMbIwMWZZNwRGZDTUpjgbRKBEU9MRJO2sQLNZKsPjUMljP5N2FpY2/xhv9J4Usl1gyLskbPfsXC/nSIXAQ4EqihKd6wLm4+4fBuNDdG2cnsP4c22zMaavAqcUj4q/cg7ThUHPwvmjySuhbEAzaHpu3DXsbvXj2ItInNbWiIK7ZbaLY3+jFou316F8Qmm01DUFTCPSt2SsaQJ43gZSEv7fmIL7eWoefTeqDkeXZuOvUYSjJtsU1NE4kQwR0zSw3HCzLQFE1+GQVDAM4jfuOkiuA9LJYx+2RFFxlmEYDwDXHV+DuU0P9nLLsQkRRkf9+X4kWL3l2doeMtfV3avZIpsl4dhc98PbWe8yeK0nVQgi0tUTwrZUHAJBsUJtfwdfb6lBR6Eoo8C7OsmNQsRvZMbzOLnhpGTYdasPbV00xSYS13M9KsKzqdn5ZNa8jRdNDFPrOGd8b54zvmvccYMlgRck4UVJ104mDzFLKcJgiHJqGM8eWJeV/1eqT0dARMCd1MgU5rESQZYGDTb6MmhsDwIGm0AnrNr+ML26ejhafFFICmm70EKzDBG01pEa8TSxGSU4hXlVOgUcswI1p2Hd7HfFCaOfjE4pwHCt9h5n8YtgrfcDI9JabBZqrcDy3ATsRDCZ4kQS0XAYJFs3qhEsRR4LGkZtPzxDB4g3RCNon5HLYsVQbDVZC3CDDCqq+pxvjrahfiIXi4zhQeSKA9Mn9X9zxOgaI+7Fb+j8A/QGDYDFSdJVJTie/JSsEA5Fv+92Iyw6egdtKR2OKZd2s1u04j12C3n4FAAnqGZaFDyKcCMDv6zAJlsIlSLAc5NzakPg1xUbIYNHxs0lmsOhLyxnuB8ORcSm+5DNYqqphPnsrOLsOnb8w4e3ohElHgh57C7UJ2KUOxbnFFUmPsQepw+qddM4LS/HE+WNNUrKtph3batoT/g2TgWkIHPZspKVVqUiH021Kc+xYfvfMkM+2Vrdh3uYaTOyfhzdX7MfCbXV4+dKJUZ97HMskTK4AS8Y9iSxvLHgC5F52i3xILwxF+LjDKwisBHXawAIs290InmVMUQUrrPLuyXznVMGGEcMGQwwgvB8vUTx41kh8tbUWp48pBcswuO+MEXCIXIjAhLVEkHpTVRS6o3plhWN3fQeqWnw4f2Jv3DJrcMx1mzwSfLKK4mybmbWg1+a1b35vkjOBYzCmdy5+PqUvRvfOxifrDuHDtcRiRFZ1lOc58OQFYyMSz70NHuyu60D/QhcGFcf3aKSgmTwuSs8UnZjItgtRjZ8FlpQsptJaRNVyM93rZ/6uxvcR2GDWMpl4J1nsbyQEa9rAAjx/yVHIcQhgWQa9chKLIVJFD8E6TOBvJLM3XnspnFn5eFC5DA6GSwvB8jUSkz6vI/FmeIqh8hZM47/B6obxANJLsPztREDAzwUfRIKZbcgcwbLXr8M9/FsQfJMAxDFRNErZ9AwZH3NUCc7wv+I5FjaeRUAhM6VOMbFbVFNDCZZd82IgW41GuTHWZklD1A1VMweZ4WaMsjcmhm/Xs3l3Y31zFZ4snWYu40QnAhARCGvM712/GD8TX8LKZj9gybH4GZtJsKi3l5JgBsvmzMK36ih4WDdmJ7QFwBolqpxFWp1ms5LNYNEsokMI/S3N/rUE+6FC9unzwM3oCOgCbFziM8xukYUbXuiexK6LVmMWO9fZ9R6WHiQOq4qqrpPAjYJmt77dWY8RZdlo88vY1+CBU+STCuoiwZx8CpOFFy1Ka8lCUjoHy++tOQiOCaqwSapmBruxGuAFLjmCRc9juHFyKvh6Wy1uf48o6rmjZEoUVUObXyF9z26bafdg/ZzC+t3zDYW4CycGsyG+EP+szBOsXjl27H30NDPIpSV+BSnO8F82rT8us2RbfnXsAADAh2uDpsHnjC8PHj/bjpo2P+46dRgaO8ix4/UQvbliP15dug/3nj4cV02PPQkUbmRMlgV/jza/gutnDITLxmPWiBLMGkHipbeNzBpAfr98l2hOdvgkFa0+GS9/uweqrsMbUPHumoO4+cRBuP3koTHHY0W8HiyzZDEGe3rl8klRP4sH81rMkA/WN9vq8MfPt+Ce04bjw+unmQI9LMuAYcgzTtND/b7Sif1N5Pk5taIgpCw50+ghWIcJtBby0FGzyuEUOTAMecCqmh5TWSYRrLdPwvPSXTip7zBMSHJbXSRN8bo/tTKmWJA9hGDJQlA9SjBKBDNJsFzN23E1/wVWe+O/tNaVXoCnDw3FKfnH4OgMjEUwlO0EezAwukn4FNmoh6flKDiLSxPaj5nBMkQ5WJ68sFktvaWdNqPMzmaMlzONkaNnsFp0J2qRb4pNAIDNKIkJl+M3+5u40IdggLEBOiB5vVANmX2NT4xg2R1u/FK+BzzLIDHtMWCLOBa72liUZwUDgPby6ZjkfwHjysvwzwT3AwCPtN0Dl9gMZ+AjAMFrXTX619QUPOZ8Ha1wA/AxdiQzv1za+gM22a/ClrqRoGW50aBrGk72zUcza0eO/ZSY6/YgvfCHBebWktl2I3P15sr9uOb4gVi9twlX/nsNZg4r7lKQBQTNuDtlsNjUZ7hNAR7jO+i6jt99sAG6Dtxo9BtJSlAI4+Vv92DKgPyIZXMCy8KPxMcg8ix65zlCyvhSRZtPMUv2sqIQrB8OtuCCl5ZjYr88vH/dtE4ZLJq92VXXjsU7iLKvrGgoybZj5rBiDC8NPh98UvB7dkcGCwjNwN1+0hAcaPJ2mbSHg5LF847qjV8fFyRFVvEI2fybxYC7vyCTDBbyR0H5RiIxEr12r3nje5w1rgzXzxjUiVDcdOLgTtlOK6kZVhqqdPnu6gN4wFDHBIKEUUqSEB8zqBDf/e6EqAIvNLv457nbsLuuA49fMDbm/t5dfQAvLNqNCyf2MXv6YkHMsFDOFa+tBgDc/8kmLAvLYgssC8mwbuDY9PvvAcFJqX5GqfWe+g48OncbRpRm47aTMue52kOwDhNwHVUAADa3NxiGwVRxL0S5DV7v8chyd+0Bt8/vxLfaGJxcNjL+yuGwkwcKI6WfYKle0rSpiFaC5URA56FkUOCSKtclEqB3ZFVguaZiEpd8eWUisJkZoeBvfCaWoB9fiQNNVcD/s/feAXLU9f//Y8r26zXJJZeekELoKRBqCE2kCAjyQemoKBZUVAQUBQRRBIWPCAoCAhaUJqGFXhJCCCmk93q97m2dnZnfH1N2dm/3djZ3AT/fX55/3e3Ozs5OfT/fz9fr+XRJsDDzo3Szz8nqFxKGmmBhEqygsb19I47mS0t+wsSyyXm1wOwBFsDkztd5yvsgXbtOAm5NL2xbumcSrKTgNwhWrM9BsNxldngkAVGw6uc1u9xpIPwndBbvNR3NY3XT0+vxBmijgh6tuLKCRm0nNWI37b7M3/RW4ze5cs/nuab2YGYWtUZIRA1SFheK2xZfyDBC8GuFSV08FuFW+QFDJfP+osgt3I+9ha7r9sTDJUeO4S/vb8s58LLGfZ5BlO9lw1JcshWsK44ey1mHjLB7aYpBTYmXm06fysbWMKfc/TYzRpaj6yAK6TLtZCqdjfXOxnYiiVROgjW6Jsgnu3u53FRDCuH0GSM4fYb7XpSB4FRTvnBo7r4ba79ZRDWbKFslcYu2pOMfkqrGSdOGMaoqSHdUQVE1PJJorwMyDSgKobU3zs3/WcPY6hDfP7k4FSWlaXglEUEQOGpCDUe5/nRhPLt8N3FFtctQs/turHOvJ6rYJMzjKHnTdcNK3QnLlv2uVzZw+4vr+P5JkzNImxPWc2hdc5jxu43xzMVHjuGkqcO4dcFaYxlVI4BEWzjB7u4Y1SGvbRH/lTmjmT+1np2dUV5d08Lo6mC/Z0lNiXGPL5ao+D0SIyvzm2M4v+bDbZ15l7PQHVXY3hGlO+puotpSjYfiHjIQ9vT0rwSSJYGkWtw5Xix+d8Eh3PC5qTy5ZAdf/vMHHDSyglfXtNAXH/oyayf227T/lyAYawLAX2PYgd4j/IZHvHcQ6967jBwnrLBKS5YtBkLAMNwQk3vndDYQNJNgqb5y+zVPxQgmJx7lDPF3Ra2rbf1i1j/8NZKR7oLL6qaxhO6CYPlkl9K5EksHVRQBr6kIef3ppvKYZFi1R3uLKO+zShjNkkbBLBsT9aElWH5TWfSZJYJSxQgWadPYSn4b/yt7f8+Dnl8Tiu62XytRe4ycqVhmZkg+BWth4GR+nzqLiFRCVPCzUWsg4ncXHSAIAnWeGPV0Ek+62x/Ww95ZWuR1ey5kwW+pfsHMQGApWEkPJfSlileo46YxRqJIghUoNZq7A1phl8pwt2GFHRY+m6DT/78ipelGuYwo2FktPjcEawjKeyxil01u5k2p5/wjGovqWVjfHOaj7Z1IosBlc8dy2oHDWdccZlNrn73dzm1XHLP++QZbU4eXMaY6OGCe1L6CpeLNn1rP144dn3MZizBaxCqepdBbv6vZzLw8+5AGjp9cB8CFDy7mnD+8T3ufcb+wSou/e+IkxhURNtzSm+CFlU3c+8amolxkl2ztZPINLzH2xwv4zSvrXX/OLW54+hN++K9V+GSRA4aV0twbzyALljJ7ycMf5nT0y5VxZSl7Okb/4EBmIE7yYK3/9BkjuPKYcbbRwSurm/loexfPr9jDWfe9x5/f3WofM0tFWtcc5uf/WcMTH+zoRxKtfrWhVoIm1JXY54CYp0/pzpfXccrdb/Pa2pZ0DpZLO3TvPi4RHGMqRz5Z5MZnPsk47m7cQwcLq99qd3eMdza226HD5YM0cCmE/QrWfwn+JpxGuTKJs0ceCEBcCIAO8cjglaMTWh7mYDlGg9f9bJYFOWCoS/I+IFjETatdf5pgWaUp2bXrhVD75MnUAluf9jL2ogLkzHKukwuXjTT2reTH8lNUtM0FDsi5TF/7LvT7ZrGz/HCmfufZorb7cvEXJKO9PF6ZLkWLy6WQgmS48EyVDbMHyyJYoscsFdSGboYmlUzgEVQUXcLnM77HsvAdqOH+QGUljdJutjlMJux+pqzeNsF0HBSyjs3LZeeypKOTw+UaVledxKXJMVzdOJ7jXW778+L3qPV309F9DCWBtP30e2++SLSrlflnX5yxfG18GxOEMAExTchKojt52HMHsZ7h4HJuV9c0/KbqFwhlEizL9GJvnJsU0xgjKbpT8ezvLDMUrKCLGACL4EfEEooLd9iPwUDX4VsnTEDVdTrNPpiBsqG88t5bqGdjyvAyTpxSb9tqDwbX/mM5q/f0ctqBw/jf/znMJijW+e6VxPSkhaplbH8+gvWrcwcujdqXcFp154M1IWMRm34lguZnm7qN+96ccdWEfDI9McUmVL2xFMPL05+tLfXlNNTIhy6HatEZSTKiwt09wklA1jaFuff1jYyqCnLmwQ0DfMo9PLIICThxSj0nTqnnsFsWsnJXD8tunN9v2fKAhxMOqOOAYaUs3d6JSu4sLOs1S13MF0gMDHh+WYP8Hzy1kgMbyjnP7IVTNd1e54aWMLu7Y/bxN3Kw0telV05b8Bd7LS7a3MFf3t/K7HHVXHpUf3X27ENGMm1EOSf99u2850JTT5x1zWG6TBUU0mYShTB/aj0jKwMZJapDiWHlfrZ1RKkr8/HY4u1MGV7GEWOqALh87jiSqjrgPW6oUGYen11dxvNvX/cW7ydY/wXQdZ1/Rg4irh7IVSONiyshBkCFxF5aODtxanwBNXI37cGbiv6sJ2TMeMup4vtECmG31MBC9RCkinQNrDWTkkipe+UqI3RtLbyQHSJb+MFTH1nP5+UXWNzjBa7OuczOhX9git7H1O433W+oiS1KFVG9nEAgPTOseMogDkqky/V6Pqw+i99sHcNZI2YyB5BMBUgaQgUrHotQAsTxUmoelzKthx/LjxPoKSMf6fCY2yBnOPLlNoywShoFOfPGZ9nOxxXVbv4OFGFPnjQ7lRKxtFmAkkpx1JsXANB25AnU1o+y37s+fAujfLvZEpsFGM3OPpIcL61ge8q9sphIxPELGkldxuvJVOUmhJfwqOc+IjuOAu5wvU4wSiUBFKlIglViXM8hYqiqhgB8+NSvKW08kKlzTs3cdnNyJyEOfrC9HwMjpWr85OlPiKdU7rngEK49aTLrmns55e53gMxgzlFVAXZ2xhhuqknO/KDB4itzxtiBv068v6mdzW19HDmhxnWZ4Oo9xvmzYFUz//poF02mamMRB48sMrIyyFETqhlbE+LdTenw4HwkJpFSedLMO7rMRZngXa+s59HF2/nOvIlckmPgWgwsNeCtDW3s7IzmzDuyFCyrDG7W2GoW/3geLb1xmnrijKgwjlmTWVViKYJ/emcLvWa5kpUPecbBI5hUX8pho4vLN7Ps1QE7y8oNnI5+K3Z1s3BtC9MbyoaOYNlZarrd56TkUUym8p2v4QAAIABJREFUN5TzkNlP+Kd3twJ6TgVLs80hjP0+UJXZd06cxCurm1m2o9smIAtWNaFkkXuPJNiqWUrT7R6s9zd38L9vbLKDhGVJzCgbLfN77N+YTBV3Le7ujvHy6pYBM5kstU7K57AppElm2kreHWk5ZfqwfaoKW9tuTUA4lb9C7o+DRWs4ztce+4iRlUHGmirgrk7jXrSvFaz9JYL/BeiOKsQVjVKfbDPspDlwSkTcBSrmQzwep0rvQdUFKh0DSLfwlNWxVmtkj1C8A2EhvBE8mSuUH9A7Oj2DJUsiC7w/5nXPd0kl3Tv3tQhGmcVL9VcWXFawVBNP4XIXy6bbCp7NBW2nkXMS1osb7Oq6npMsqD5jFikVca9gtcn1fKgfgFJizLylykbyp9SpLPIdXdQ2DYSYGGJC/FFOkx6wXwuS5KvyC8xPLsz7OVk3HvKSN61KWYHSYtZ+tUoEhawSwXH6Do4VV6D17rGbv4uxXlZM84+UI69ry9pl9t89vZkKrWWy4vGmj6lFEOUiSGs8Yqw3LvRXSyuEKMdIq6jvW9PvvUJoL5nERckf82z1FUV9TvL4iOseZEEjEg2z/IX7mbX2Vvyv/rDfsrZKJu0nWPsakijwz4928uzyPfZgz1kK1FCZPg8vPdIgCtMbDOXfs48b1MHIZLrx2dUs31G4BDsXvvfPFfzl/W1AWsHySALzp9bz+BWzufSosfzqnBn28vnIoqbBz55fwx0vrXP1vb1xw5hiKEz4PHapGjxi/pZs+DyZCpZXFhlW7uegURWcMn0YM0YaExwW2bxtwVoWrmnJUI96TYJ05PgadnRG+elzn7C+2X0FSY9DwSpk5d8ajvPg21voiSkZ29BmWrRXhwZvDmLBOk/jipoO/HWU9L1zXe56BEuEyWWgZ5EujyNkNx++dux4vmc6+1kE5Bf/WcO3/7ack6YOY9oIs1rHkYOlahrzp9Zz9MQa+3MWKfQ6SlwBygOyrcIUey2qlqlHHsUpkkjZYbn5FCyL7KU03Vbo9sYgrbXXOCd6hzD79J9fO5Knrz4yozz400JvTGHZjm4+2d1jm9NY53r5Plaw9hOs/wI0bVvDxdLLHF+a7kdRJINpp2KDU446mncgCjqdQiWSXPzJJI+YwanJ2/mV9xuD2o5c6MkTZNgotDJGbCGRcB+0bNmHb48XHgyGhRK2afWo/qqCy4pmLle+7KNUMs7oiGHde0ri9qJq3hOxCPfKd3O7988ZN0LN7EnTY+4HM2kjCeMBr1aO55bUl3nBd+pAHysKcUUlhYzmTc9ge4NmbfUAIb4ejOPs8ToULJO4SFrm5x6t+wGT43+hefQZGa9/rudvPOK9g9KmRZy89Zes9V3CtNbnXW+7YhIcxXFOta95G4Dn1dl0SJkTCF6TYHn9DoLlMxWDYgiWSVLiObz+/GXGQ9uXLH7Q2q2X8q52IK3lMwovnIWI2VPV29WBtPxRAJ7S+g9uLIKl7CdY+xyCIBAyIxnawgneWNdqZ7dUhbwcOT5dpGkNKq17xlCaXLT0xmnuiffrxbDL44roM80e21kTItakUvYg6/AxVUyqLxnwey54cDFgKEQDlYNZSPeUDX6o4+w/y2fT7ndR4q7ruq1grWsOs6mtD8WheDgHtqv39LB4S6f9rHQDy+kQ0rld+XDNEx9z64K13Pzc6pz9N9UlQ2dpbamwv3l1A9N++jKQSaSdEwWxpEprb5xwXLEnGnIpWD8+bQpv/+B4Tp9hmEHpA9iYg6Pfxzy/rN/8/ZMn88NTDrC3Mx3aqzO+toQzzNBeRdPSbodm7pSFA4aVMX9qPYt/PI9bzk6bI7lBmhDlPk//ung7lz+y1Fwm9zokBylM2T1s7gjW1vYIC9e0sKm1j0cXbefWBWt5bNH2Yn5CQdz7etrD13ntf7S9kzfWtxalthaDdA6lZAsYFioC+9ayfX+J4H8Bouve4GbPI3wozgeMGWkrIye1Fxk5TvS0bKcB6JZr2BsfPKumOLwP3Fb8kV3UEqPcl3nHSAoeIEYiFqWkrDAJ0lIpyvUwCLAtUnjG7cWqr3Dl9nncObrw4FSUrVK23ARi49KFTCHGem0ku6mlN6bkdL/KhXhfD5+TltBJZt1zqqSBDVoDPbr7ge1B7S8wSV5OXd/lQKP9MCtmQFRwe3MENPtN90P/AARLxjh3PL70AEU2CZactV8TmkACL7In8zhajo9aMoqcihEQkshFTBgoog9U7JBiAGm3YR37kTaJOVkDGC8WwUofA4sgenB/LUR1L/enTscfLOWSrPcC5cYVGUwVr1JHLeVzLwJU7wlczZ6eBLPefIcrtbX06EEeSRzNd033MguWfbx1L9qPfYugTyKcSLG2qZfLH1nKRNMeuzuazIjrOH3GCOaMr2Z4uXENjawM8Pw35w5JmO7Vjy/jo+1dPPW1ORw+Jn3vTQcNu5eCZEnMGLQHzRy4EeUBFtx0NIpqDAT7EikEQaA84KHM76E84Mkblhp1DMJiijpgSRXkNqvZW4yrLbFdHUvyfK9XErnvwkPte+Rra1t4cskODhhWhlcWGV7u5+Tpwyj1yyTMrKdkSiOppomQ9ax9dU0LH24zysSLuY87SwT7EgMTsyPGVPHB1k7G1oRyEqzavQwZzgXr3hJLpo+h1eMkioKtwKiazoufNHHtP1Zw1sEjuOn0qai6nlP1qAp5qQp57YFzPs6dTGksXNvCnu4YJ06pY2K90Q9rTUp4ZdFhrCE4FKzM7KyUqtukUJZEDm6s4E9fOZy6Mp+tTrrNrnTCLukrkIMFZEy2OCE7SOGc8dWIomBvUyE88/Fu7nltI9+aN5Gg2VddDKl3A2dJrbO08rqnVrK5LcKr3z3GPi5DCWuSIeiVM+IV5k6oGZJe04Gwn2D9F0BtMUqEUlXpXqTBZOQ4EekwVLGIb+9sxo0TUkcZ5Hbkwk+7fsJIfxPbE2+Bo40+iWl16lLBCve0Uy4YN6jr2n4IvD/g8lZ9vBsiZClYUp5w2d6VLwCwVR/OEcI6wt0HU1fmrmY9YSoEiSx1o2nC+XxlxVTOLRuJ2/ShyeFFHCq/xdK4UW7p0WLMEtYyPF4GDE2ZoN6ymme8N7InOQk4DnAQLJLomoaQYwbOqysggNehYAmlw/i3OpeoPJ4pjmWth1y2a5plya4no0iqcV5IPvc3x5Ro7OOU45waEV4JwMfaBKZFMk0fvHrS2GZfWsFKZ7S5f/D0iWXcnrqQ6aVl/QhWqNIoay3Riu+zrGhexHXyC1TETgAOLOqzq0rnsryrkws3/hokeFw9kQQeuiJx6srS+3R9/al8KT6cL00fUSiOez+GAAZZSNjGFpYJiqZDRyRBXalx/dz58nr+tWwXvzp3Bl88fBR+j8SBI8vzrbYoWIpPdsO5nZNThMtYdq9IfbmfI8ZWMrw8gCQKSKLEG+taufQvH3Lc5FpmNJQzZ3w1j185Ky8hcpZeuSFY8SFUsCBdcpc9E25BEAQ+NyMdrbG1PcLCta009cRZvaeXmWOqOO/wUSy9YT6/eWU9v399k9ED5FSwzIHt717baL9WTA5Wg8PUoq+AgmXdZxMpjUQOBXQoFSyPacaSbeqjaBrJpMbRd7xh/K9qGT1EF8xsLLjuuRNrCPpkDh6V+zroS6S4+vFlVAY9fHxTOv/PIpVb2yO8t8norXU6F6Y0nUWbO3jg7S3m/2lC5pNF6kr9nDi1eHfmbBQq6bNUvEuOHMP1p03JuYzkIIXzptQzb4r7tg6nQ+4osxzZKhMdLDRNZ/5v32JzW3py09lTOpQ9pLkQU4xrNug1rPBPnFLHIY2VrvLBBov9BOu/AMFeQzr1N6Rzqt4beRXXNs3j8pqZzBrEulPdRr5WMrB3PVQlXpnVvssICQnUZAuSd/A3EwtB3bjgglkqlSJ4QQclUdjpDKBNLeHo+IOs9F/JZHVT3oG+hbQSU5hgWb1CUp4SwTujn6c+WcMtnoc4xfch63ZPgUa3BMv4/Yms/hyr8bKYGSTLLMIyjwhE9/B33y/YHhsJXOV6PQMh1dfBweJmPJpD1fF4jJwkQSGZjGcoPhbe0A7BS5JjHAoW1RO4VrmaA7ylXORY9ksd9/IN71o83XcAJ6Tf8JiDhmQUSTXKaySf+0we1SJYSeOcamneTaNuXBvP+m5i8cZumPlTAHQ1hVcwA1cd22yRLS/uj4vlDGbN3jtRXmVck+V6uOA5m43qzmV8Xn6OxdHi/f3KvXCX5w+cIC0nKfg41/M+V8vPsXXXQpiaDqqNJFIoyBkRAvux72CVCFoEy+8gOW+ua+OLRxg9tGk3u6EfkFjrzCZY2aVVhaBq6f5SCyMrA9xyVuZkgHNg98e3t5BIaQMOfJyDsJgL982hVLDiisqizcYgPF+JYK7PALbi5ew5spQOp4PiZUeN5cJZozM+C8VlBF02dyxb2yM8tnh7wbIr27U3pTJnXDW/OmcGz63YYxuODGUP1lNfOxJZFLhtwTre35w2ClJUnWRKs8+Xey88lB2dxn26UK/On97Zwkfbu7h87tgBs9Gctu+5Xr/5+dV8bPYXemSRYybW8p9r5lIR9PD4BztY09Rrb+tFs0dz0ey0E20ypZkTBgLrm8Pc+fI6xteW8OM8RCgXCvVgSVmKWi4cPrqSZErbKydAZ9Cwdf+x+qWKhZHjp9njq0gylUGuAMoC6etHKvLeUiwsBSvklTlwZDl/unhwYezFYH8P1n8B6uPbAKgdd7D9ml46jF16Hd2pwTXhdSle1mmjSJSNLrxwDoiiUbIFEOkpwjbcBYK6oSYESzNlbEWwFCx3JhedkSS9BInpXoJCgnB44J6WbzZfz0rf5dR3fFBw3aK/lO1aHR1Cbql9Y1jmBW02G3xGzXU87N5hLmmWqyli5kPM6knri7rvQbMUNskyYjAd64oxZCgEyyAiJWWS7Lh5vOLR/jfklKrxVeW7XJ76IZKUHuT4HAGjToxMbOEIcQO+7JwmS8FKxZBNgiUXMfBfWH0hVyS/R2uZMcD7uDlp/K8bx1WPps+ZlGKsP657kJ05WF4/C9VDeFU7FN3lw0AJtzJHXM04YXe/9wKhUmK6F6+QIlpsHEPSOBaCt/gSh/nae5wmLjE+f+HfafcY7lGRruaM5ezSigIqwX4MDYJmiZ81wPF5JLtMcObY9CTU3z40qhIe/8DokYgrKj/+90quf3rVoLfBKpmSs8i+Ry5ullkU4O0fZPb1WYO4tU29nHnfe1z/9KoMgpVvEOyEcxCWTeByYSgVrJ2dUXabRgP5SgQBHl20jbteWU9PTLHzsKzSpFRGz5HlOJdWjw5urLAzmZy/r1gyfd0pk1n5s5MyiEAu3LbAMAt5c30bE+pK+OIRo/jrFbP4wiENhLwSNaVDR7D8HglZEu1jeNHsRt74/nEEPJJNIGtLfRwzqTajh+iZj3fz5JIdOfubl+3o4sVPmmnuHXisYD1nREGgucfoM0ypGpoVeG3e53993kHcfMY0yoMepjeUM7IymNHrl+1u2dQTY9INLzL++gX87rWNhOMKC9e2snS7ewdggIaKIMdMqmV8Xe5JQ8vYYntnNK+ydOqBw/nFWdM5akIN65vDvL+p3bUK5bwO//yu4cS8avfeGaxd9dhHHHDjS/Z3ZxutjK4Octjo/uXH+ypo2J7kdJRQ7+6O0RNTCvbsDRb7n5yfMXq62qmjk5juZfiYdM5SyDwZosnB9T69FjiZq5PTuGNKcWVETkSFIFWEiYY7KasdMajtsZBSkvgFBVUXCAYzbyop0QsapJLuCEZnJAEItOoVjBZa6WrZSVl5/t4tv9pHmRDD46KHJzX8MI5N3s302jKzKC4T1vHR/JWQBKXPPcFSTYUulUWw6mJbWO+7mD2tDcAKV+tKEyxjXRbBkvTiM5byIb29mQRrmzASnxqlOgchVvLMiHtRmSDsYljSC449K5mOg2JWDxYmkRCUKB7N+B6Pzz3BaiqbwUKtmpMl47xYuivGQu0wJord/FD/M2IiTbASuodzEr+gxKPzhGMdoiTyde06FFVnvabjczFmCzZ9wJPeW/m4dy5wbr/3X5eOIqaozInECJW6q5cHEBXjWAje4tWlkw8eS3dsOuVn/gr/mJkkPMa5m+hpzVjuwB2P8m/vi3R0XwFMyr2y/RgyTBthlDdZ0RR+WeT5a+bmzTKyAuQBnlyyE68sctvZe3+fB4eClUVyPKKAIAycM+SEIAg0VgfZdvvn+MObm7njpXWIgsDHO7pYsrWTFTu78cmi/T0xRbX7Z4698w1+c95Bth12ru0Dd6GoFxzRyJHjaxhTPXgV1ml5PZCC9dC7W9nWEeXsQ0f2V7BUjbsXbuBfy3ZRGfTar3392PGcfXCD7QwJmQqWWsTsfls4Qalfdt0LDP3t3O8635js3RcDUOuZMHlYmW2bnZ3bZAfliiK/+M8aOiJJTpxS3+83Wbtla1uEfy/bxfjaEg4a1f8+aq2/uTfO7F++xujqIC99+xjAeDZZEwg1JV47LNiCtS2nHTiM75+UmSXa0psmMAGPtNeOnp+bMTyjtDQbVrnt2xva+NaTH/PkVbMHXN99b2ziuRV7uPv8gznrkMIVNc7tLvXLtA6iPPDVNS0A7OiMUlvqs8+thooAe3pi7O4yssSs68k+5vuoRHBkVYCzD2ng0NGVaJpOW1+Co25/HYBVPzvJ9hnYF9hPsD5jNG1YRjmwWx7FBMcM/7i+ZdzreRBt9xzg5r1ev5UKn33TKAYxMQQaxPqKm5UZCNFID2VAhABlWbOl7weO542uicyU3eV/lG74Ny9672e0aAwQe9t2waT8gZSySUbkHOVs2bBKS3K5QiUTCW4QHqLPE4JABfSCFnW/j1IWYckqEQyVluMTFIKae4MTycyPsko4baJVhCFDIWjm9lqGExa+FbyD7R1R3vRU9zNSSSYVGmjDk+VEF1B7WOi7jo5kOXBp+neYipuURbBEk2CJqThe01DDF3A/aLIezHFzULatw1CAauuGQQvIToKlwkp9PJU5CLhXElFUlWRKc1V2lDJVSjVPXtV95d9jTVMvz6eCFJM2I6ZMguUrvim4ZuZ5MPM8+3/FVwkRSIXbM5Yrje7gUHETH+j7IGR8P/rhps9PBeDZ5Yba6fNI+D1SP3JVW+qjLZxgXK1x/jsHR3uTHeiENTCUs9zHvjt/EtdmDS7d4qpjxnHJkWNo70tw9K/esF932lw7Z7l3dcXyhm9b27f8pvlUBAv3B33+oKGZEITM8q2pA5RhOcOGLQXNImRWCdbOzhhjqkPMHlfFmOoQ0xvKCXol7l64gREVAb41b6I9837c5FrqytyX5p96z9u09yVZcv28oj63dFsnq/f0UhaQ8ckSU4eXMaZm6MqDf/niWhZv6aTbtJF3huBag+s9PXHuemW9bXfvkQX7fM5F9qyMqnc3tfPB1k4uOXJMHoJlLBf0SkSTKilVx+8RWX/LKSiqzref/DhjuQ0tYf78zlYm1JXYZXmHja5iXG0JD727lSeX7OCSo8ZwkMNEojzgSTt6FtGr6AbOcy9fn1ZLb5zd3THqy/zpzCyXNu1OBctp0qFkGR+5QUNFgN3dMepM9dPqA6wu8aLpOr0xhba+hG3SI7sI8B4MjhxfYxuDxBWVWbe9Bhj7ZiAleiiwn2B9xmhuaaJaL6OrZHzG65VqO4dLH7C0b3CuKuFwD6APimAlpBLQING3dxkouRALd1MGxIQA2Y+q1yrO4Z22dh71u3s4St3bmSLuSK+7s385lhMec4DucWGS4HU0AWcj1tfNxfKr9BLiE//FxotFEKyoEOI9dRo9/okZNgUlFQZNKdXd10DLpq24bBIsWTZLBIeSYJn9S1pWiaCV4ZWrZCcVbuE9/7dppwL4ov26lS/lyepnkuxQ4szztbnxdOYuq2Vu9XgC4YWIiTYurXA/eJocW8G3pdepbI0Co5nV9hQTpG6GlUyCFvAq6XII61jnIlAjpB7iQoRkMgkuZr7sfebJfa5Vhox1dEVz9/jlg2QSrGLKJPNBC1ZDJ2iRTIIlKQY5FPeCxO3H3sPuEZVzD2yevHI2D769xQ7otPo/VE1H1fR+5KgYWAPM7EFVsaRtfXOYe17bwPSGcq4+bgIBr9RvMCNLgn1/zVZQ8ikAPzh5MtGkOiSOicXC2id1pb4B1SFn2HC6RNC4zlOabhOnz88YYffVgZHZ9bcPdzJjZDnXnDDBvp8++JXDXQ9ydV23bdqvfnwZcyfW8J0T86vP5QEPPTGFrx47nlfWtNhmDgA/P3PakBKsbe0RVuzs5tKjxjCxrpSFa1t4d1M7N54+NaP083evb+KaE4w+PI8o2rbkucRTLcvlL5eVO6TPJ4tgKaqGIAj4ZAmfnP78lY8u5VfnzGBERYC/L93JUROq7WBt67JqDSfY2NpHd1TJOC5lARmvaeRRbGRCJJEikdIIeqWc59bciTVcPGc0jyzaTr5L8Z9Ld/LrVzbwjePHZzgiuoFdruroBxxXEyKuqEUTrOwe9z7TFbPEJ/PXK2ZR6pMz7if2BNE+KhF0wrlv/bI4qMkoN9hPsD5jvMnhXJK4n+sPHo+z9U7yG4MaKRXJ/UGX+EPXVZT5+ugRPgDclyA5kZRLQIFkZOgULCtAOS72n9n3DUBqckGIZZblpXqaBlzeyjjy+HKrCk4EYs2s9F1Bd7QcyAy3jEV6KQdi+BGChtrmLDUrhNbyGXxD+Qmn1g3jNMfrJaXlRumkkEBJJvB4C5PjJqEOtBiied7IPuMzHn3oCJauGCWb2QqWddOK5ShnVcwyT4VMMuI1zSN8WT1iVs+YnPWbPcEKdum1dGkBXtHm0qkm+XppYQt/CxMjSznS8y8Wd9QC53Fq5FlGepr4sPQ24zek0j1Qqe493CL/mag+ApiXsZ7H9R9R5+ukpfdYKMucFMkJi2DJuc+1Eb4EE4VdRLpGQRFBCrJqrFfyuzf6yAchZMzuCdHM60i2SFxgP8H6NKCZxhDzpw7j6Im1/cpqLUyoK+GOczMjJjySQbAUVWcwfg6/+9LBxJKqbbSzt9jVFWXBqmYWrGrm0fe3c/GRY7hodqYbnEcS7Xt9dp+Gsx/jj29tpsQv8z+zRvPlOWOK2o5XVjej6TrHTqobNClzBrkOBGfY8AHDSjluci1ja0JUhbxUBDw2cfI7tueJD3aweItx/fWaob+abhzXYga4kaRqb9/S7V0FXQBrSrz0xBTmjK/miQ92ZLx307Or+UqR+3sgWL/j4FEVnHlwAw+9t5VNrX18e97EfvvUCmUeWxPkX8t2AbnJk/WadWzyEaykTbBkINmPwHsc19rG1rBtKZ5SdVsN+tnza+hLpDLt3B0EpizgwWtWIRVbIvj71zdx/1ubue6UyVx9XH+TlxEVAY6dXMsji7bnVaWc2V3OEks3mD+1ng+un0fAK3HG798F4E8XH75X5XMdZg/plrY+akt99rUd8sk53Td/c95BJFVtUCLAQNjdHSOWTFFf5s/4PfkCm4cS+wnWZwwroX3i8MzBotcc1HhT7pz0ckFTVar0HjyCilizdy6CAClPCcQgFdm7psdc6PYO50fJ6xldW8Yvs94bpe9hjrgewg1A4e2W48aD6R3vXDZGS5DEsRw5wPIeO0S28Oyc1+ulTIj2IwgA8agZIisGkEuM4ycXQbDyuRkKokRYCFFBH73d7VTXFS4e+4nvR2zvi/J6tXFzlu0SwaHrwWrzj+Ep9Rjk0mkZr98Q/jkzfB+yccdDMPqsjPdSSUMtTAnZBMsgHD5ByXDQsxS37BJBvx1SqtkzwIEiegwskwxSRt9KmdYDApSOnALLIaimCZba28xF8mtsVMf1W01K8IBuBEy7gW72SiHnLtU5r/sh7vQ9w+ItP4JZ7kODuyhnl16DJ+SujHYgyCUGwZITmSY2FomT/fsJ1qeBuxdu4Hevb+K7J06y1Sm38EgicUUjmdIGRSTyZez8Z+Ue7ntjM6dNH8Y18wpvm5MwNffGueOldYyoyLwGvJJITYmPey88hISicfdrG9jZaU7ImAPU7miSX75oTGz9j+mu9+uX1/P8yj1cd/IBA/atANzwzCe0hhP24HEwsKyyOyPJAUsx/Q6CdcXR47jiaOM+8sXDDbXq8r8Y+XteSSRshgr/felOVuw0nh298RQ+WWLLbafR1Btna3uEqpDXFentzlLCCwUNWwqbX5ZcT2juLdJOdZmZT0lVo7bExzUnTOD3ZhjtyMqg3ZM4UNCw1bZjkbd8vGZGQzkf3zif3rjCsXe+SUrV2d0d45onltFYFcwoV/RIYkYml/P5/MKqZg4bbUxU+z0SHgeBKQ94bCt6p+2+GxRyEXT+tuz4Awt2dpfqIFguFaygV7ZLA2NFuCxnw1nGubktwqxx1YysDHDJkWOYPCz3c6SYMta9we8WbuTvS3fyyy8cyJcclv/iPlavYD/B+syxudUYpE/Ico/xBI3COY/m3kkuGz2drVQKKr2EKBtEKdGK2tP5R8dY5pYcxKF7vZZMhDUf72vT0UP9G5lP6/orP/W+wodNQeDg/h/Ogi9pKGtrhp/NL9cP53MM5+KBljdDZH0u9olVRmipXk4kTIKVFAMkGo/llHdvZ/yIsdxXcK0GlEQfZUQIyv2fChGhhAq9j0iPO4Jl1XzbteveAPMSd5JE5u1B9mVY2FI+m98oVXyjPlO5kQQBr6DaLoNOWI582QRLkmUUXcIjqKRSSTvE9zVmE1I7mRvIzDOpjGzlD57forQ3MlyrIiZ68XtOwy0E010RJUYiHjVIsy5RM+4gblIuJuqt4dfmspbqlhL7z/4qFsFy6XCJ+fttm/ksaAGDmOvR4hw67wh8l7XdvfynYWZRn8u5DQ2Hc8PiS/H6pmXkXXlNguUJDl4l24/CsNwa98bYyBq8Flua5BY9MYW1Tb15c4ay0WuWBflk0R64Z8dOeCSBgFfi9BlGqe85h40Pa5zTAAAgAElEQVTkO3/7mGeW77FVA2fZsabpPLN8N3/9YDvdUYVOF2W16XLLwZcUhnzpdQx0P7VUuXiOvl1I/6YlWzv52l8/4vjJtRn5Yr2mu5koCtz7+iaeXLKDW8+ebhPMgWCVB1oIF7Bpt1wRX1jV5HDayx/YOxhYJOjl1c3EFdV2mVNUnboyP987aTJ/XbydrqiS0Y9j7epc4tT0EWVoWroFIp8phyyJVIa8tnutomlEEimW7eimN57i0ctmklA1XljZhJyVg3Xj6VP54uGjOPnut0mpGrFkOkczQ8Hyewh6ZI6fXEtlqLj8MOsayadWbmgJ85tX1gP5lRfRsc3W/nOrYDlhnbedkSQ+WaS6CGXJSdKtTL3pDeUZ5i2fNiLJdA6WE2770waD/QTrM4Sqqryh/A9dvlLqStZmvOcPGWy/n111Eehp300l0CVW9utzKgbtNTN5Sq1hrDR0DcNp2bj/g0+XjAtaU9wNYkOKMfNXN6wB1mu0FrBs/a36RXxajO+ECs/M+0wjDG+OXiYlZmZjiH5KKmpZpzfiTbofjI7d+jdW+n/LopYLgD9mvBeVSiHVTLTHnSuh9XC0BlqSJLKVBjSdQfdlWMjXm6SaPVlqjtyyfAoWgIKMB5VEPGYTrDv1i+hVUiwvzZxJDxLjVOlDtsZbOMOzg7juQRJvc73tgtnzJapxejpaqAN6hFIqyit5VD0ZMQ6/0oxBjWqGEati/weL9TsUlwqWkDLWJeTpwRKCBsES4sURLGsQXiho1Q2CwybyV3U+B6QyrwevObnjCw7m7rHvIQjCKcA9gAT8Sdf127Pe9wGPAocBHcD5uq5vM9/7MXA5oALf0nX9ZTfr3BewnGMfXbSdre0RvnDoSE6ZPszVZ6c3lNMbV/L2Z7iBruv86uX1eESB786flLNPIulyZt5SZkZXB9nQYvSSOmfEzztsJIeO7q++2pbNpjThVAISKY1r/5F2Vc1VkpyNuD3xNHibdp8sseT6eQVL9qpDXmpLfYgCtIbjCAhUBj32b7MIlqVIOftewOzTUlSCXjmdP+bSYc0iWDUlXtr7kgVzsE6aWs8ra1r459Kd9iD4W/Mm8se3tnDlMf0V/MHAUndeXdNiO81BprmBtY9eWdNCS2+c4yfX2UpDrgyo604xnJf//uEOnlxSOJDZIhwpM3sLjGfmiIoAo82yQK8k2CqRmqUEpTTdJu0Bj5RRxltr9uY9fGnxk15WuHS+AOvNrX2sM6udCipYmu4IanZ3Q9jYEub2F9cxtibEs984ip89v5rTf/8u3z9pEt88wb2a7jyP8xnVZOPh97ayeEsHlx41ltk5nEOzkUipvLiqmVnjqmyjjIGQtmnPfFZ+CvxqP8H6LNHZtodaIYGCF683c8bDFzJudv5BKFh97YbZQ59LN758KDUHceH40PXzeJuX8SP5CeTkLCAz+M0iWLpLglWqGQSrcfgwDhXeZFQXkKdIUNV0HlbmA/BDX2Fp2up/8gkKqZSakYuUihkDB0UK2g/L7BnEAWH2NOk51I2Xys/nweYWzpDdDbDeSF2Mx6eQVNcDZv+VZMweD7Yvw4Iv2sRkYQelemZZjtVfpOZSsEyCpeYgWAnBS5AESiIGGOeoNQPfz9bdVBtLNYPUxgUfxRQWWARHTMUJd+yhDugVK6iRREp8Mn2JFH3JFGV+j13+l0vBsn5HyuW5+UrNxfx450yubjwiZ2C4VZ4nxYszkInmyPbYW1hholbtvIU3hdmUqqOZXVY36O/YVxAEQQLuA+YDu4APBUF4Ttf1NY7FLge6dF2fIAjCBcAdwPmCIEwFLgCmASOAhYIgWI4AhdY55HCW6LyypoXDx7i/bz9ymTGoUzWdjS1hJtSVFK1aq5rOH97cjCQK/RwD7XBjl3bh1rOisSpkEyyfLNpmHLd94UA8koim6dz/9mZSqs635k3k+Ml11JT47HIii4xMrCvJCOmFwgM4XU8Pon15+tmKhZtyptvPSZf6fv7377Jqdw9PXjmba/+xHFkSuOqY8cwcU8XoauOepKT0fsrjip093LZgrZ1F5DYjqDtmXMMNFQFXBOsHJ0/mlTUtCEJ6km5SfSkrfnpS3h7AvUU+YppUNTr6Eqzc1WOrWq+sbuaN9W1Uh7y88f3jEIWBVcN0GWHu95ds7eT3r29k5pgq/nzx4ciSaO9zq//K2seeLAULsEsBFTUdiBzwSNSU+Nh2++dc74N8sK6X0jz2/5Y65ZNFvnlC7iBuO4xY17n3wkOIJFWGuSy/CydSvLaulYNGVXDD6VM5ZmItb65vc52jZaHU7+Ha+ZO469UNNrHZ0tZHRyTJmOoQtTly1Vbt6uHl1S3Mn+purHPz82t44oMdnH1IA789v3CFk6VgWRNYhzZWsGxHN+ceNmqgjw0J9hOszxA9rbuoBbrFyn72E/7SKhapU+kSK3FfCJWJRLdh9hDz5a6rd4sR6h6+Ir3MiNZpwAEFl3eDYPsqvib/h8Xx/qegZaKgpwpf3Jqm8zf1eGr1Lk4eVsm/fT+jK16Crn8n5w3Z+cB1MwARRJGE7sEnKCSTMWQ5rVBFVZENWgPdvhE0enXukB+gPJoEjs+/QiesQXqO/pz11fP4z+4mjsKdtO4njldQEXzpG9ht0gP4hT6UxFwC3sFL9LN2P8I1vn+zuO1H4CgWtY9Xsr+CZamQKbE/wfqefD0dEYU/SsZgStd1xqlbSAoy3qzpJYtgVei9IECC4hpiJYeCFTUDdSPmxMMZ3qUEUnsId8ygrGEUmjKQgmWQLjXp7sHTpYfYqg9HylEKC+ApNV73KcURrAXJyxF9Kl59JRRFNfujMihznvQm1bE+dO0Eux/uHv2LdCkKyyoH7nP5jDET2KTr+hYAQRD+BpwJOMnQmcDPzL+fAu4VjIv/TOBvuq4ngK2CIGwy14eLdQ45stV8NzEA2bjlhTU8/N42bjx9KpfPHVvUZ7N7Y5woNt/Hcg4bU51Wbn2yyPPfnIvsUAgEAe58eT26Dg+8vYVDGit47PL0VIQ9mPVK/VScQkHDluLu/RTcwvLBIjjlAQ9NPXE8ksCXzfDfZTuM0vakqtklgtMbyijxyXRFkxlBr25zsI4YU8X9Fx2GLApc8ejSfuYh2bBjSMzvl0QBryQOObkCOKSxkr54in9+ZJhWyKJAyjRm+WRPL5eavWn1Zb4MN8uBSrmssNjPHzSC02eMyKvYtPTGeWdjO2UBj91DaJmK+CSRF1Y22Q6KsiQS8snMGFnO2JoQNz37CY+bBiApVefEKfWMqgzYBDkbreE4iqrTkCO7Lh/SBCu3gmVdL0dNqMlbbufswSq2r8nujzPPA4sItfUVn4cVtDNcjevzL+9v49FF2/nZ56dyyVH970npfjd35/hR42t44oMddnlrLnT0JdjVFaMq5E33bJvb9fMzp9MbVzhg2L6vzNhPsD5D9HWYCpO3PwEKlVbyJeUGRAE272UPjdJryPAp/+AIVkN8A1/wPMLH7ccCXx3UuizoCUPu1r05SuoswpEqrBL0xhV+rZxHqV/m/LpGFF2iUuijJxyhvKz/uuOxCOeIb6PKpcCprrY1IXjwoaDEY+DoR9leOYcLk3dy/shRzA0FOUd6GxkNVUn0M2nIBcH6fTkc5spMRSy7byEXdE3FKxg3Ea83va55whIqpD4641EoHTzBElTjZmv3M1nfb26/5TLoRHfZZC5JXse4uuFMz3pvk3cKO/qiJHSrbENlgfd6403pqoxlfQFjv8uCcROOi4Ut9jO23V9Km15GFD9SLMEuvYY+v2Ggcqn2byZ6NrG57XxoGIVqkkIth4KlmUTRbfmqdXPP1zAcKDfUIb/i3kBG1zQq6UUWNNQh6I/yeWRulh8hKCTo6b2V8gqjbDEyhCrZPkQDsNPx/y7oJxbay+i6nhIEoQeoNl9fnPVZq+Gx0DoBEAThKuAqgMbGxlyLuEZ2CYu/iLI2XTca2x9+bxtghN0WS7Bs9TiH0uDJMigohNHVQWaPq2KGI5PIK4tMHVFGazjOuuYwtaU+akt9eE2lvS+R6qdKWftg5a4eOrMU1lgBBauQ3f2nAasHyopjUFTdNsiw++ZSGklzvz50yRHUlfp5f3NmZIJbBau+zM8p04eRUjVOnT4sb8mZsS0ai7caJCOR0rj/y4cB+yZcGOCMg0ZwxkEj2NzWx7Id3cwYWY5XFin1y3SZx/b4ybU8fOlMrv37ciAz3DkXLv/Lhyzd3sU/vzaHI8bkd5VVcpzbthugLLC2KW1y1FgVZGxNiOe+OReAqx//yC4VTGkaF84a+DqffdtraDpsvu00130+vWZJbVkg95BccpT/5cPJ0wznRetcKwYWoe6MJLnmyY/Z2GKMzwopWJqmI2SpiwHbkMo4963Jlnzl7HKR9xYrU24gVfqxxdu5e+FGrjlhgv0cs77/0+wH20+wPkPEu/YAkMihMMmmha2VpbE3DkgrA7P4l3IVsxrmDGo7PUHjIelR3OcyFUTSXJcnF8EyyYkLgtXeZ9yYq0NeEEV6hDJq6CLS1Ux5WX8pPdnXzm+895u5TDe42tQHxAuIJhS+qssZepI1Oxn0SUiSSKdQQhW99HW3UV47suB67f4cb3+CNUHbykXS6wSaY8CYAdeTTMbxAUldzniApMzLW1WKy1jKB1E11iPIWeTRIlg5FKyoVM6b2sGIwf5lZs5wQ4BkPIYHTMUw88HkyyISTTVzKNzynUZk1PEckbifuaNqmFdax5cSv+Mr40czB4jJZaBCrMcY1MQJsEYbTbevv3LzTNVl/Gr7Li4vm+Lqe09qf4RTPRup6fsR0H99oQpjv5Ro7glWPB4jIGjG8fYU10ydDz1iOUG9ld6OJsorqlAUhSnqBmJicMjKq/5fhK7rDwAPABx++OGDGplmD0CKUbDOuu89Vuzq4agJ1by3qWOvAnbtxvgcKoBVIuhWwbLc83Rd51tmiKtF0v65dBd3vryerx83nh+ecgBehxFGU3eMdza2MboqRGN1kAOGlTGi3M+enni/rLhCBCuRZfzzaeFP72zhgbe3cMXRY+1etDK/xy6PXLi2laBXotIMSlZUjRrTTt0npR0InVBdDj4tyJLIHy46bMBlemIK1z21st/37Wu1zyKLN54+lUMajSqClz4xqgqswXbSYYV+zZMfs609wu+/dEi/XC4raDibx7T0xrnwwcVcPnccF85qzLBWv++NTUQSKXug7XW4Bn7rhAnMn5rpXOxUTrPNyHIhXZqvIYnuzr2bz5hGW1+CxqrcE4cWwXprQxsvfdLEKdP7P0sqQ17bXOPm51fTFk7wk89NcdWnZF2bnZEkz6/YY7/eOgDBSqkan7/3PYaV+ey+s2U7uvjJ058A6QkjS0XNV/6Y7jMc+N6iqBo7OqO02+Yo+ZevMvdDZyRJ1Pz+olyHhwj7CdZnCLXHUJjUYO78mzqvQiLVS18sTsBbvAvg+tRw/qUex+ENBxZeeAB4SwyC5VWHjmAJFsHy9b9hCaaCJbgoEeztaGKOuJoKn9GQGxf8oEMynjs/TIkbpCYpuC8xe9r7eXZHY1ySVZZmXbgh80YSFkqp0nvp62p3RbBE1SCQYg6CNTWyhMs8D/N+cxI4d8D1JOMmwcKDc7htESxFKV7mz7m9WsLc3kwFa0/tXH62NcnYstnMzvpMrplDC19SnsEvb0frGg3100kmYoSApODpVwDoD2Se/3VzLylq253WydZMuHUTTnrKIQFKnzGbu63mWK5PVnHBiFHMz1rPruA03taquUB2lyk3OfYx06SVfKLmJlCldY18KfkTInIlz7n8LbFILwEgJvgYGnoFYamC4alWIp3NMH4asXAXz/puopcQgnDlEH3LPsFuwFlMP9J8LdcyuwRBkIFyDLOLgT5baJ1DjnE1IX57/kHc9MxqwolUUcQ2u79lb0hxvpBhMGyzL5zVyAF5rJbzQRAEfnDyZDa0hBle7ufnz6/hofe2ZnyPTxYJm8vv6Ynz5T8vyWiuzxVGfMXcsRzcOPA1WFfq45ObT85w6Ps0EFdUWsMJOvqSxBUNUTBUYNkkWFc+uhSAV757DGDcI1+91igr13WdaDLVr5fXrYL1/Io97OiMcvK0eibUDXysnKRqX1u0A3RFkjT1xNnZabqTOs4z1e5/yjT18EgiG1vCrGsO5ywJtXbLB1s7+eWCdcweV833T57M71/fyOa2CNc/vYoLZzXaCqFHEnnwnS10RxUeu3wmXzi0gSnDymxCl3SQKU3TUXXdtod/4MuHcdK0YSzd1okgGEpIrkkQS5FNpDTXVuezCpg7OJWw19a25iRYTry5vo2t7RG+Oz9/yLQT9mSnuR+qQ146IskBFawdnVHWNvWytglblY2bkx5zxlVz4+lTAUcPVB4Fywog7yrQv97UHWfeb96y/x/I+GXNHkORXLqtiwcvPpxwPEVd2b7J2RoI+wnWINC2ZTnVIw/oN+B0CyFizNpQmru575/adxnmb2dP1xFQPjnnMgOh3ayfzdVYWAz8JsHyq4MLPXZCTBrrEnNk7GwfdSY//mQE82oP6Ddg74cdi3jSeyvL43OAc1FEH6iQjOcmg4rpEKcI7oemlgNVUs28wR+x+R7W+f7O0tZrgJ+azn8Q7W1ztV4xlZ9giaZqKCUKKxvp35R5OacEGfShV7DErPLHcM3B/EX1crG3v6YU6PiE78n/IBA7DMPELY25yvtMltexrvdqYDqKaX2ezJE5Jnt9bNAamCTuZrs4inEHDpR01h9WqVFMUekwr4tqk2ApZn9aKmI4+Vn2srkGqdmqWyF4NOM3efJEApSEQiwVpqMkdT567xX0xX/gHvErHH3YDK46JneQcTxiPDxiBFx26BVG3FMBKYj1GOdurK+HMowQ7f9uD0E+BCYKgjAWgwRdAFyYtcxzwMXAIozZitd1XdcFQXgOeEIQhLswTC4mAksAwcU6hxyVIS9nHzKSZz7ew1sb2orKobEGq1YbQyE3tVxIz/L3P+8n1Zdy29nuJ+o6+hL4PRJBr8Q3jk9XErywKj077jUH07kmXyyyF1dU2zbaKh8cVxPiBnPwNhAEQTAGb5/yuMo6blZ1RYlPRhAEW9kAY8DcUBHgngsOtsvBAW589hP+ungHB5ullYeNruTa+ZPyKhvZeHb5HhaubWF8bQkhn0x3VGFsTSjnueS0kQ94JK56dCk7OqPce+GhrpSaYvGvZbu45YW0W7KuG26TXlm0zVMWrGrm8Ftetd3+ZFGwFbVc57RmvtYbS7F0e5dt155tT644bNCt9ybXl3LXFw2ThAfN/qvmnhiJlEpHX5Ijb3+d4eV+e1LBIjlXP77MzlarL+u/Xz2yaEzYDWFkgrNcOF/Z4apdPTy6aBvTRpTZ3z1QrpYTnizV2goIjiZVIolUTnI0rDw97u2Npyh3hGg7K64KlQiOrzXOtU1tA0/gZ4+/Bpp0eHO98Rxb3xK289Q+C+wnWHuJJY/+hJlb7mXJqMuZeflde7WOdz1H8Zbi4eiRuUv4FMELuntL6GzMav83o6Q4dd7BKVjBUqO2OagNHcGSUsa6pBwESwxWsVUfTjeFZ0uVsFHWpXiNUgNF9IMKSiz3ttoOcTlc7fJhjr6Cg8QmlPA0cMwKikoUv6Dg8RjrisvlkIJ4b3u+VWXgpbJzebjzQL5Q2z9dTA6ZwcVKb7/3sqGY/UDZYciqRbBSQ0OwJFPBkrJ6sNI11/1nGEOda7hGfoYl0STwrYz3LOMLq+epEPk9KXknAD88YRRfL7KMpSzRxCLfN4l0l9EXb+Ba3yo2Re4BxqD5jRuwZmZRJZQUoOcsLTok+h4HyB9Q0i6QbtfJD1kbONRaEAQqgl60cCsHvPIdQkKCEcp4Hnm/PC/BSkSNB1FSHLqAxqS3EmLpvs141HRrFN03an8WMHuqvgm8jGGp/pCu66sFQfg5sFTX9eeAPwOPmSYWnRiECXO5f2CYV6SAb+i6rgLkWuen9ZsObChHp7iJMcsJbZHZuG+5yRWLkZUB6ocg+PPM+95jV1eMt39wPI0OMwDnwNcicrkMFazB9FMf7aLZjN1oqAiw9uen2GVh/62w7huWQYBlXOAcxAY8EiGfzJkHZ95DLEfPzeZgc1J9KUdNcN9D3WMe94qgh8v/spQ1Tb08/825HDiy/yDTUrCmDC/jxW8fzYl3vcWm1r6cgb5DAWvC6qLZjfzizOlc99RK/vnRLu4450Akx3nR3pdkVFWAmhIfQa+Mxb9zbVa28mVt+wzz937hEGP/Kg53Wrvc1TFAt0oEn1m+h1OmD+NQs3Qxpel2mLEkCui6XjCIt9hy2lhS5fevb6SmxMdlefomDxtdxS1nTeeGZz7Jm4O1uzvGPz/aRU+s3mEv707JDnqN/K4t7RG2d0TxeSQe+MrhlPrlvIYnQa/MqKoAOztjdEWSmQTLsW+sEsGSPARryvAyZo+rYurwgafynBERZX45Z8SP/X5Aprnw0GmfYz/B2gu89EkzKza0M1OGCXueBfaOYL2XmswKtZ6TRueulU6JXoMsJPbOqv386BNUe3po9n57rz5vIVhq3GyC7H0mVzZ6KGGnVosU6t+Yaj2g3JQtaDFD4VF9xg1VMQeduUJvIT2YL4ZgXRz/K5O8G1jbdTLOfihRMfaHYJY5Jj1lEAelz12m0RppMu9o1XyhvH85obfE2C9eFwQrIZVwo3IJoVCIHzle18zLOzVEJYKSbkj4UpbiVqG08gXxbRq7JwAHZbxnOUHqOVwELRMJ1Qz2tSYSUjkULIAjx1ezek8v5x9VvJPlsJHj0OljuNbJnniCGqGXppA5Sxswzm/BtEo/ZPP9bPb9mfebvwZkxh9NjS5hlvwci7tmgAt/T69u/P58ChbAFdILfNX/EABrfAfxTvxA2vsSdtlFNhJm/lpiCMmPGqiCHkiZZZLOEO3/dui6vgBYkPXaTY6/48B5eT57K3Crm3Xua2iazl/e30bAK/HoZcVl6XizZqBHVxVfUj6qKsi7Pzwh53uxpMr6ljBeyTCqKATLFa0kq+/C2d9lEazKkJdtHZnPFsuS3VnGpqhGL3IkkWLxlg48ksBho/MbG6zZ08vNz6/mwIZyV4rXUMEiEqU+mUcvm4k1LLzymHHs7Izy5JKdGTP8cUXlyNtfJ+STuO5k496m63D+4aM4ogirfsjsSbYGtOFE7tIrS6m31JHsLMWhhm2UkjLuax67LE3Ho2c+6+889yA7E0l8OZM8OWG9ZhF36/9sNXZ0dYhTpg1jcn0pL5rnYFs4QV88RVXIm6HaymLauVDTdNvd7pKHDZdDi9/k6+lx/k436Iwm+d83NzOszJ+XYDl/Wz5RypmDZZf7ulSwSnwyD186k/c3tXPhnz4g4BE5dlLu1hUnKoNeg2BFk4whZPdFvrCqiZY/vM9TXz+yIMGaOqKMv11V2CfAKl+cMbLcNiDJB6e5y/VPr6I65OV7JxVfBTZY7CdYRSIcV7j2H8upUWfxQ/lv5Alrd4U2c2aurjT3jKEiZA5Ai4GWUqjUe9EQqKwdnM1yqLScpC6hIKGlFES5eJeabPxvyTf5sL2Lvzf2LwKsCa/lHs+9pNqmAocMvKK4SUB8hrL0SP2PeHdDKz+tODRrqG/AUrDUHA5x+WBlH6lZSqKUMgYFkvndnaUTea97D3HdXXlFQkknwmfDb6qGfjXc771sxMUQj6knMd6XSbA2eCazJxqiqoh+s4Fwb+gamsJN3Fg7LeP1ush67vLez4qO2UBmv45ulhXqUv/9nTJt0FWTANoKVp5j89jls4gr6l6F6/p9PtbI45mqrmWEZsQXhKqM0lwpWEVSl0hZpZSpOJKgI0n9z3Pd2jYX/YGQJli+QP4B7znJdPdV1Tl3cdBfX6Za/ZhweA5lZf37TMKeOn6h/A81FcNxHwFZAMEa4rqHpNWjaCpY/xcI1v8rEAS4dcFao0/n6HFFWWU7B4hlfnnIQ2K3tkc46773OGBYKS9955gBl9V1PW9ju7NkyRpgP331UWxoCbNwbQtvrGvlw21ddn+F08jCIgA7OqNc8MDigtvSEUnwwdbOIQlZLwb2/VyAYxyD1KuPm8C29ohBsDwSKVXjofe20htL0RlJkkzJTKw3nh01JV7uOHcGS7d18ssFazmksbJg6LSu6zT3GM+oYeV+m9xGErnNQKwSQb/ZR5R02NrvC2Rb/VtELqVqnHPoKI6ZVMtlf/mQdc3hjP4aQXBBsGwFy3jd+i3W66dMH2bvv/ve2ATA08t28cii7Vw0u5HjJqVNmDxyuowwpemccdAIDmyo4P63NtvfIYlCv7I6C94so45CCBdwELRgqVL5goYly+5c1+2SS7cKloV4amB1zonnVuxh5S5jgtsyoHFOiFgtKv/6+pGE46lBt6oMVMKcDefEzhMf7KCu1LefYP1fwPaOKNGkiqeqkWREop52EtFefMHiOhU0TefEyH9oE0upDWW30huwSEBqL0oEezqaqRR0OimlykWg7kDwyBJTtMeJKRqrUlA6BGdNXyLTOtOJEqWTI6X3WeEitFdImgTLb+z/RHAYe9CIarlvENZgPlfwbT6ottKSOcsqq8b/sjl4Xj36Eu7dMpdrSyYxz8V6j+37DwdJnYRSB2C4RqdRbg7+y9SugutJZ3tl/uY/ln+bZT3dPFUyxsXWFMZWGlijl9qukhZkn/H7ZS3HeWopWDkIlqVqaWYvWjjUyFmJnzO2vpLf5vh+SRT2ilxZ6KiYBh3pHoCyamPioWPCOUz6cDynVg434qlTlh19jgeC+TvcZLQB+DAJlj8/6RZECTTo9DUwbNLh/ES6iJFiEzubL6GsrH+QYpdUzZ/VzzGvYugCgHdMuYLz18zmnIpRHEdmiPZ+fDoQBIGgVyIcT7G7O0ZjVdC1zbNz0GGZtwwl0kHDhWflY4qKqun4PWK/wZDzf6fqNqm+lEn1pQQ8kkmwNHtdFqWf8IoAACAASURBVDa39fHbhRvsmfBCQcPWBNbe5IkNBpYtfCLH7KuzhEoHbluwzn7PIwmMrQkhCgaJjCsqa5p6+ePbW/jy7NEFCVZvLEVMUQl5JUr9HvtemS9s2CKvi7Z0MPeO1+1SzH1GsMz1/vvj3axvCds5RIqqEfTKBL0ydWV+1jWHM0KlrUvAOvU0Tef8BxZRW+rjhs9NJRxP2YTCIiFW9cvjH+zg1qzeQYt0WeePV5I4cWo9s8dVsXhLJx5JwKpYVDWd848wbNkfW7TNtvwOeKS8bou3nDWdhKoxvNzduKs3NnAGFsDapl5uft6I4ctXIuhUsCyCWszkQls4QW8sxcwxVRwwrIxnl+9m+c5uzjl0ZE5r8wUrm+y/Y8n+16u1f0dWFn6GJFIqW9sjVAS8Gb1dThSjsFr74kszG3lyyY5BjRsGg//T/rurln/Ie68//6l+Z3L3J9zruYfL5BdpEo0BWsu2tQU+1R9d3Z38XH6Iu73/i9+b+8JKDULBalr/AQCtUvF2vblgXfyFggvdIjKAbGyVoMla4UGsaLoRSgHjBmDJ9tYFn42WmjlMiT/E/cNudr2tVuBsdvaRRzWOi9fsI6sIGvso2wEqH86IPs1PPE8QUvuHzFaPGEtKFxF1lWhs4OOv9jZznvQmM7XlmdtX5ExaIeQzf5D9+QmWbvV//X/svXeUG/X5PXynqmu13ev1rte9N9ypBozpLYZAIIQOIZRACEkghBZISEghgUCA0DtfiukYAzbFBncb97r27np7VZemvX/MfEYjaTSSttiH3+t7DgevNJoZjaY89yn3mhAs0iIoa6a9MdiwQRmJA45+q8skY3Bi1i2msPBpfk8+lx0Apf9uRN2RMjGAVnQLgdxmXNbIY7FSHgubK3MFK3Ty37G76DjYr/4EABDQDJBDnY2my5OHmLMfHxoFTnIM1O8laZVhiT1MsA4miCLp8X9bhkYLI81UXDirChfMUIUPC118r7yM1u7vwtT7PsVVz69Oey8fo2Er01RCGP949gScMLY87X3dE0cLlMm5/oczxmNEmRur93Vhv9ZOmM1oOJrSAnewMLLMjZtOGIlhJU48tHg7PtuqzjWuqu3UJbAdmqqgMUbnWRo2lkFNsQuyoioCkmOZC7ElBKlcC1Dd2oxKpmf20aNK8PVvjofbxqKhK3GuDRTBMhLqLY1+w6xS4ruRlrbLn12N2X/6DNua/Jg/rhwXzqzSRYmCcRGr93Xho03NOHZ0KU6fXIECTSiEVLSOH6smn4Zpsu6doTgausIIxUSUe+0YXGBPmssy7odRCEM0ED1jNciqwnPkyBIcP6Ys56CeVLAyyZgDyQIfPod5AoVUtkRJwexhRZgzvCivds+j//IFbn59A56/YhZ+d+pYLN3eimeX78OOZvMumibtfHvrurk4fbIaC88ZXoybTlBFbbLZKBjx0Cc7cMrDX+OtdQ0ZlyFxTGcojqP/8gXOfWx5xmXJ9UJI7qHycvzBVrB6ujoxadF8AEDbxG0oLesfIpENYsdenMGsxCaJQru9GkMjDeiq34bq8aY+lBnR1dqAYgCdVCEqMmRCJEZroeoFwQpsWQIA6CjLqsOXE0jPeLQvPZEG/F/4CvC2OER5NYDk4JPVKm6MnD2I5QT14me1qsps/2Icxy0G23gxgMvTlo/LqjKakofsvf47pMwy8bL6u3BOlWB5bRQ8CEMI5TaDRdrHeFv6vtAsh9Pdr2Jbh4RP/SJGW3RqsZ278BD3JLZEJgG4UX/dSYvwIgQp3j8zWJdFnofIhmAXpwEGARIyX8SZVbAkQrDSq0E9tsHYJlfrpsHkBjpQvktFo+cAm9R/d1NelGuZbfJw7tZMnSni98WlEyyKEEUp+zGVZAVXxm9VzcJtmYlK9cwzgZln6n+HuWJAACJdzabLMx27cBa9HCPEI5C1hTZHEP8U0upRW3Q07oo9gONH18DaTecw+hNOw+C2LQ9icOSIEoRiEl5fU4/1dd24/e1NeHDh5Ly2HRMkdIcF04CcTZHPtoIeMJoEmOMrvLBzDOaOKNZbhn79fxvx5toGXDy7GudOq8SXt83TZyiihooPCYA92vWa1QcrpQXuYGF4qRu/WjAGL363H39YtBkXza7G/PHl+MOizdjREsCzl8/EmHKPriwYF5Nbn0aWubG3PYTb3vweUzSxBknO/tyNCBKGFjtRU6zej10pPkSpsHMMqoqcGFrsxJbGxKzvQM9gEZCYQpBkfLSpCe+sP4DPt7fq77f4Y1AUJKlQAsnnlSwroGkKgwrsOGfqYIzVhBKMJs4A8K/PduL5b/fjnjPH48Ur1Vjt4c92astSkGVFP285hk4y9l27vwuhmJhE6B18/x0jQqKtTKHJ/owp9+CX880TkMZ9fvqymXnvB5GXj0syHGASFdC4+fnT3KPGP4MMPluTh/gwdpAX//5iN8KChK5QHL9ftAkVBQ5dtt0MRLVyd2tmJcFpVT68evUchGIirnphjWWyh4J6PMjv/4MmWBRFnQLgX1AVl/6nKMqDWT7SZ2x5/2EQoWZ/S/3BI1hBVSEuzhciyhUBkRWItu7Jez3BdtVWJchm9j/4rPgi/Kd7Ls73Tsi4TCaUta0AAPgmnZL3Z81wX/xvqOZ3QW5+ESjJj0yawacEYKMEhF3pSoGsVsHilOxB7GOeG7G36xw8UHUMAGBwvBazmdVY4TcfmuzNIK+iV1qSCcSL7I/ARJvxsyK1hWB4x5fYZP8lNtQfhVzm43lFU5jLMJ9TUlQIdLSjvjOM0eWZFRVJZS11ruyWjnsx2b4aGxqfAMZdmHV/suE08QsUs91oRXKFjuw/b1JxjFAONClFEPn0/f9qyDV4vv5k3FM8HscA4Nq24I/sM5DDkwD0/RxLxfDRiYCToxI350I6hI/534HppgFs1Fs/Kc6E1WoEi8rBBDtqUJvKx7xTcBQDYUDoMSdYJc1f4d/8f7Ay8GNk80jLFaViExbzv0G0vQDACnTLTmxRhmG2J/PQ9WH0P4wV/Xxk2gHVZ4igVzLtciKDn4p85kr8UfP5KwB46Pz0yVhSOX55ZR08dg6/OzUhYkNIlJNn9LZBr7beiCBlFIIBEhWsfIhqfyK1MkFIaonLhsE+9d7CGwgWOcbXHjcc6+q60R6M6UFuLsR2apUPX952vP53YgbLuuuEJLSmVvkwsdI7YARr+tBCvHXdkVj4uBqbOA0Ea3drEEu2tqCm2IlzplXi4c92AQB4Nv23pSgKdo5GVJDx1Nd7ISkKLp49FA9fmEg2+bVjTzwPdeNiQ/LOWMFauqMVO1vU4J5jKLA0hQd/NAkMTeHe97fos0YA8MrVsy2VNt9a24Da9hDOmz4kzRjZDLlUsHQzXgui7bFzmFLlw4heSuzzmrx8T1iA28bq9yIzgi5IMloDMVCU6jeXuh6WpiDKCloCUXy0qRnDSlyWBIvMHu5qzTxz7nPymDuiWPfmsromnr18Fl78dh/++skOAAnT44ONPm+VoigGwH8AnASgAcBqiqLeUxRla1/XnQnRcBCj9z6v/x0J5CaL3R+QwupMjGL3oX7MVZhadyxOdU3IOxyMaO0/YVtmCdZGz2QskYtxMpu7TCsA7G/tRJ3gg5fpxugZ5qpQ+aJM6cAwugXbw9l9mbJBjMdgowSICg2HCblgeTXbzynZK1iNght7lEo4vZraEqdVCgRzxcOSA5/j//hH0dp1InLN/sv63E1yUP2hPBdtUgzXFqjtCKzWKsiJuaktkvmcTBLepHfZ2L5hBjKjJ6fIm0v6jFP/tHVyGrHi7cnEg3eo39tmQoi/LvspLt91FO4cOg7HpLyXam7I+/fhEvYzbIj2zpYgGxw2Ds/ZfoqR4fXYVjhPl+Mo9PlQSddBlGlAUWAX1Guc86SrKIk2HxqUEoTp7A/OSCyOIvjhYPMzZ5WdpUAHIAfN/dSUqPoQUvj+86rxuD2ooRvQKauZbNI/byWFexj9D2OmNZ/Ky7q6Lizdkcj+94pgpVRSjGDzaBEcXuLCk5dMT1LKM+K55bXY0xbCz+YOxahyT1LFOrU97bKjhuHrXe24+fUNOFFr+7JzDDiGgiApiEtyxhmrQzWDFY6rKocfb1ITJKTikmh/TBxDEtTq/4YqyT2zphAfb27Wg9xcjYaNWHjEEBw1sgRVGWZgFm9pxjvrDmBdndqi/puTx+DIPCTh84XPyWP6UB40pc5TnTqxQp+9+3iTOs9zzrRK3Dx/NN5edwB1nWGwNI197SEEYyKGFjvhsXNoDUT1Tpp/fb4L4biEMycP1jsRAOD5FfsAJNpIicS38dw2Vg6Nr1cVOUHTFC6cpSZOn12+L+l7DPE5k6wHUrFowwF8vasdM4cV5USwaJpCudeme3hlWgZIzKGZYfxgL969/igoioKuUBwsQ1nOdaWCHINjH1qK6+aN0M89M4LeFojpsvmn/utrTKvy4aHzp2BVbSeaeiL6+UrIULbnyMhS9Rm5pzWkVyUzIUE2ra+JNfu7END2/VBVsPojVTELwG5FUfYqihIH8BqAs/thvRmx9tNXUAL1ptCjOBEJ9Z8/UzZQEa39y1GEisFV6IYHte3WBmlmEHvUG4rozDyoTh4MZPYlV3yxqweXCr/DPaPeBtdLE+RUiJr8uRTt+7EOB1WSFoYDFG2SLdUCeC6HFsGEWpV6I9GrDoI5KbGFmzGT3okSscn0fTMsrv4VxkWfwbZBZyW9Hta2TQIJ3lmg7XcOBEtRYNMIpN1pfhM+XvgSy/hbMPL7v1muiohESClzTkREQsmhnS0XkIoblyKaYneogT4hjEYQc0Czvn6dYGkPQVKJk03mtfoL34+4Gj8Vfo81pT/SX3PYHQgoDrCUjEigC6/xC3GvcAn4Qely8PuGnoejY//GktJLs25L6GrAOvvP8bZ8U9ZljaA96j2BCWcwrI5rWb5+JFjeInWbXiUIWZIxtPFD/Il9CqNC6/ptG4eRHcaAKJNKmRmWbG3Bx5ubMUardPcmICfZcbPt5tMi6HPyWDBhEI4ZlZ6gkGQFH21qxovf7TcVVdhyoAe/eHktntAU26ZW+XDqJFXcgdzrOYbSq3vRuAxFUfDd3g59fpCgpsSJ0ydXmA7oDyTaAjFc8dwabDqgPud0HywtMLzsmVV46bv96mvacb14djUunpMwaifEgHw2F8KcukxVkRMza4oyigbsbg3iky2JKnk0zzijN5BlRScJEwZ7cfbUSoyr8KZVT0m1kmUo/H7RJpzxyDfYWK8ez90tiXiLJIJiooxdLQHUdZg/e43KhTe+uh7T7vsUi7eos3EeO6dvd/aworRWPTLXde2xw/HAuRPhc1mTFlIBFHI0o7949lCsvGM+bjlpdMZlyHxVbXsIjy+z7piKCjKm/XEJZtz/WU7bJzBeh3bW0CJookLZ1JNIgu5uDepzkS+v3I9fvrYB4yq8+O0pY/UkRyaJdoICJ4dSjw0RQcKBDLOna/d34f4PtmLJNvV3E7MkewqdiTjCihAPJPqjblYJoN7wdwNM+nsoiroGwDUAUF1d3acN/r1xAv4V+wM8Dg6fh0fiwYJJyL/j1Byqh4CcsT2DiarZbdpVhOFadmJfey/8oYLqjU1xZyZYY8PrcCPzFQra4gCGZlwuFZ9vUzOZ88b2TZ7dCJGx9pfKB5FgN7wAwpQDZtqLnMOLlfJY9DDFyPYNfhP+B2KcDA81B4AL0KpftGh+kSoWqnaZQNtciMCOqJQIPGRJxtnSpwjTNji5U9X91maxeCn7zJwsxsFQCgSFgY0335citx01dAu6ArWW61K02TCZTiVYrLat3EQ3rDeigIca4NhsyRUsu6cIY6PPAqwN21M+RrxAzNpOjmp6AbfYHsfq2ssA/NPwPfpHVt4M06p8eHvdAVQY+sYpioKf8sKDCPydzfg0PgWN0hhcUWriT0YUwnJ4eMa1ZEQ8T5l8zqsGlErMPHFDhF1oR37KpZbb5O0IKXa4qCh6ejpR0b0es9ilWBnP7k9yGP2Hhy+Yigl3L7ZUKTMDCRCJCW9vKlhxXXks/Vp18Sw+uPHoPgsgXPHcaqzapyYpiZCA8d7QFY5jXV03BEnBtdprPKM+i0kwzdI03r3+KPAsDbedxWfbWnH1C2swssyNz351nL6uE8aWmwppDDRSK2YkuCS/kT8q6sIBBQ4OMVHGdfNG6B0LiqJg2Q41ueJzchha7ESxO/vz6uoX1mBdXRceu+iInCpR0RSRkK92tqPMYx8wQtrUE8G/tNY/VeAjcX6TYHlPaxCfbmlGoxbAcwwNOkWmPWQye7etyY8bX12vtyGmarwYJb6DUQFdYQG3LhiDUWVuDC12oaErnLQcALy2qg4xUdbv9QunD0FUkHDH25swrboQV2bwrMpHECZXGNVEMyXcFUWBJCsIazNTbI4KpARJRtg8bdkiKEoyRpa5wTE0tjX59dld0tL7yxNH4ZSJg7BYI/DZCBYAlHttaAvE0BWOo6oonRBtbfLjf9/U4kdHaObRFve4619Zhw81lcPrjx+B207O3zuzP3DQGhMVRXkSwJMAMGPGjD5Zhb945Wws2jAEu1qCwIp9+nB6f+C9h2+AL7ATc2//yFTdj42rWRTWXYzBPgce5h/HxOgehLu+gLMwD0IT1dbjzSy9Oia0Epdyb+K7zsEAzs1ptd99+zUm1b6EVezZmDcmu1FcrpAYNSCVYn03G45qFawYbZ5Z4wtKcUH8LnjsLNEkMIWiKDhJXgGeERF1qEEsrREsKgPJ0eW1TUQXMiF1YBYAotEg/sQ9jajCgWH+DACwu9SA16ZkJ1ixaARhxQMJDMoyBFKeQepwb0H0gOW6ZMGcNMp6BSs3xTsriEIMLKUgrjDgueTrwsYxiMIGiEgr75/d8Ff82vYl9rTeC+CKpM/RNAOWkkER0qv9fyArWOdNr4IkKzh1UvK1GmS8gNSCYGcLOrS+fTO5a9LOFM+FYEXUayWe4TzPBHnkAoxa9gImlZXgbZP3GVElbow9v9bDbPDTHriUKAJdLaC1bRAT7cM4OCDBXL5zQ0ShjQyJ94ZgiVLyLJARDE3lHHhva/Ljs60tGFfhxfzxyQTHGPSR+RojaSOzEmRfXllZh+e/3QcAKPXYcM7UwZg+tBDDSxPn5TKtNdJqQP5gIlW10J0ygwUkuh4+veU4pMJIPOYML7acXTGiqSeK7rCgV712twbx0nf7UVPsxGVHpZMBQrBGl7sxvsKL51bsw0ebmrDq9/Nz2l6+6IkIeG21mou/aHY1djQH8OXOVowq8+gCJm+vP4C31yeedxxDp/lghU1EFwg5SD3viUiIcd6KJBBKPTbM1syMW7Rq6rq6boRiIlw2Fvd/uA3BmKjPGNEUhfrOCD74vgmyomQmWCmt7/0Br6H9MZMP1q7WIBb88yu91TBfDyzekBiwcwxKPDyGl7h09UYjZg8vxme/Og6t/ihm/enzBMEiojTa+U28sKzaH/Xtm8RZRpCKoCvlHmGG2rZEIaArR1XngUB/EKwDAKoMfw/RXhswuGwsLp49VDeM6+kngiWIIs71vwQAqDtQi+ph6SXbvRgCWR6LgqJqMDSFcWwTRsqNqK3dgmF5EKynCm7CpS0X4JnRR2ReSCMBuXrudLY1YcjiK/BbrhVHjx6KYvdpOe9PNkiaZLUU73sFK6qZmBL1uFTYLHxEjIhFw7BTIuIKA7s2y8VoBIvJIEJgJRueCZM6F+N1/mX0NJwN4A4AQDjohxOqiAMJnwnBcuRAsKK0E9NjT8Dn5LAhwzLFQ9Tzr0xqBhQFyHBjzURMSAVL6YcKViwaAQtAAIfUI0dRFBwcg4ggISpKSQOldtGPUsqP/VR6wKf7TBEzYq1FUMmD/OYLB8+YBhsRzgdIQLBlLy5W1qOdK4aTT79+Klu/wnrbr7GzcTZgSn8SINVeMc+KXHGBGwJYtAfNiTEnqoEk6+jfTHOI9gJSG0LdrWC1OUK2n0ncYVjDZWPwzGUz8v5camWpNy2C4wd7cdvJala/L9h8oAd/X7ITC48Ykk6wDCSDZPqN+04CM7L/T3+zVw+aJ1UWmLZRZfIKa/FHEY5LKPXYcsqg9xeM3S+DvHa9Vck45+MwLNPqj2JdXTcGFdgxtUpVw/3LwklYtqMNx43OPUlKVN3KC9T7TYs/iudW7MORI4ozECz1+XrRrGqcMLYcizY0DphEO5D4/sNLXLjv7Il4c20D/vTRdvzoiEp9RobMZw3y2nH+jCFw8ozBB4sQLDWIv3BmFZZsVRNipBqqpFRwfza3BkCiOssxCYNgY4UpdTbLZUucVyTp8eXONnykzYpZCdCYyc9b4ecvrsXaui78+8JpmDvCXPSswMHh58eNwH+/3JNxPknfX43k5NNiDAB3nzkeN7yyHu3BGOwsk1MF2Ock6rMCFEXRSfu2Jj8CUQFbNXXKXEyGHzp/CgRJxtAi85EJQljtHI1rjxsOjqYzitwYxUA6MzxHDwb642paDWAURVHDKIriAVwI4L1+WG9WTOxZimX8LThy9z/6ZX0H9qu9re2KFz2c+Yn1OHUBLojfBa5G7YLscqite/7GnXltKxAVIIOG22mlv62F7jkolgHArjfuxBC0Yi83EnMX3pzX/mSDrFWwEO97BauHK8d9wiX4zH2O6fs8Q8OBKJxSD2SLLEXQr7ZrhiiXTj5kTwW+liaijsnQUkmqOWzuQW+B2I7Z9HZ4wnX6a7GQeuOIUInqhNOtBrxOJQeFOeLRYjGAXVw6CEHFATciCHS3Zlxu0+AfY1T0BXxelfybE/VDReo7wYoLIjbLNdhFmR/Xx5mH8D5/B6Ip+0lrc3S0iWkvpf0GlJRcwcqnuthfiHNqYCM2bsJd3Iu4jX3d9MbNMhQKqSDsUma1IwJBq/YKeVawSrSHEcn+pYKIqHB5mptnQ4RVz9+ovz1BsByHCdbBxGur6nHXu1vyrsYYA8TLj6rBT+fk34Y/dpAX1x8/EgsmmHdV3LloE371xoasM8EksDRTgGMNM7dkn48elWhnI4E2mfUy2oIYKwJPfLkHV7+wBpsP9OgzM7+YNyJpW/9cshPH/20Z3t0woPneNBgrgN/efgJmDVP99h46bzLOnqqqHRsFQDY29ODnL63FI5/v0l+7YGY1Hv/p9JwJT1SQ0BUWwNIUSlzq/YMkKlNbAY2fIfsSt6he9hdSlSiNRGRUmQfHji7VJeavPHoYbl0wBnaO0Ss2JGYOGWafCekixJ20yMZSVAN/c/IYPHf5TEyqLNDPwdvf2oT7P9iKqCAlkRHyGVJtJUTsiS/3YO1+NeZwWBAsm+6rlVsFqy0YQ1sgltUUmHzXTAkFsr8ktmBN5tutMGd4MWYPV89VexZRCHIP4Fm1lVCSFfijCSn7J77cgxteWY/usIC5w4t1GXYrjCh1Y+wgb0ZxHFLB4lkat586Dr8+eUzGNmpjgumTLc266MnBRp/TOoqiiBRF3QBgMVSZ9mcURdnS5z3LAW4OqKFb0BE1lzPOF237t6AGwF6lAmLMPCgl5UaSlRKdZUAos6RyJhDvA7eFNGdqAJoNvq7NAIDIsXeBtvDd6Q0afDPwVEsE5f1gAtvJlOAZ6VTMLzQnsRRFYYPtWtgoAdH4WbA7zL9L2K/28ocoJzQNQcQq5+AS4Q7McRXhRyaf0Y9lHgSLEF3K0GoXDakBdoxKEGSH3Ymb4jcgBBuelGQwFg8rEjhYmWBSNI0WZhDcci3a9u+AJ8PxikkKBLBgUgRNvi85Ay82VuLYwjnoqxtajPXgjPifUOaxYZXJ+6OpOgymW9EU9gNIWCbQsnq9MCYEixxXWjuuIcaLbXI1Io6DPzdRW3Q01nbZURF3YTqAIG1OXsj3yMWjTdIqWFKeFSyPjcXL/J9RiVaEAyvh9BQmvf9r5/2ob2nHa0Nm5bXebNjkOxFfHqjCWKYMVcRE23mYYB1MRAQJDV2RjNXLTDASrBtPGGXa3tpXvLPuAEJxCfeeNcFSmc8475IKswrW8WPKsP2PpyAqSPi+oQfvbmjUM9BG76EWfxS7WwModPJYX9eNJVtbcO60Sn1GJLUNiVQeDrYPFk1T4FlVfj0mJua5i902nQySAP2GV9bhA21WxIxMrd7XiSueXY1pQwvxwhWZr/dWv/pcK/fa9QpHQiTLPNCPaq+3B+N6m+XBqGA1dEWwrcmfmFUSZVx6ZA0uPbIGf/54G574cm+S0mJqiyCZ83HxLLwODrKSIG/kYyQYf2ttAxaML09qbyXnYCAm4unltbj9tHG6ObO6n+r7hMi8ds0c+Bw8fvXGBrRqqnhWBMvn5FFRYM+ZrPoj2WXa46KszzNlahFk6OTKWSYiZgVS/bIbzgOzKtFFT63EjuYAXrpqNgpdHIIxEV2huP7bFLp4dIUFnDmlAqdM7B8tgEQSIPv1nNoqanYvOhjol60qivKRoiijFUUZoSjKA/2xzlzAu9Vyqk3ou3Q4AESaVM38sGJHJJi+TklW4Ii2wE7FdUlQxaWJVAQzVxjM8EDgTizi70SB2JF5Ic3oNBfPHUWWUSGq/c3lo/rHfNSIuvIT8YD4U9S6+r5u0kPttpDujFHq8Y1FM7fbRQOqkmTUIJlNHmaRDO2FDbZRWCQdiaBnpOn7ZiDVF9pAdIWIWsGK0wmCRTM0PmePwefydIQzZA0JlOZNWG67EffH/2K5XLdNJSuB5t0Zl4kZMjtGtBeMxwfyXHTYqsw+lhdiWTxliJCDEE3OvBMiYkawGO38pjX/rDXFZ+HU+IPYVn1Rn/c3XxwYchr+Iv4EWyIqmYlwhabLkX1m5OxVQTGmnrsSa1GlNgFFURjGtKCGbkF3a2Pa+wFBQQBOuJz9m0TZMfgc/E28AHV0NWyaEiZ/uIJ1UEHa3fPNuNKGAMgoV50PdrcG8fGmJuxsMa/Oksx+NiVBQrDMMujG14yZajvHwOfkdeUyEiSSgO2W+aPRExYw/x9fUvUCvwAAIABJREFU4fFle3Rj7M5QHNOqfbhgRhXGVSQnRUiF5lD4YNkzVI9Ie1vqjApgHgQqikoEwlm8rJp009cEUSDfOxPBGlPuxlEji7FsRyvu/3AbgIEmWIlz9MrnVicUAw1kitPOj483NWOpZjqcaBFU/0+erY8u3Y27zhiPjXcv0FvVCAm7dcEYAGpbH0lmp24DAHwODgxNJZkXk/dJRajEbUN1sTOpLTBTlQUAfnvKWHx7+4lYOD1dJMkMgWiyErIZInFJV+rL1iJIkG+L4LsbDsAfFXH98SMwaUgBGrsjmHDXJzjmr0vTlu0MxRGMiXDbWPxkVjVuPGEknDZGTxyTua1wFjNwI15euR+3vrER6+q6TN9PeJlR+HZPB5buaM04r0XuUdOHqs/xH7JM+yGD3au2FtjF7O06uYDqUEv085iN8OxPl7js8fvxne0GbLJdCXLuEkllNpJBUjkDRsu1mErvhduZuX2INqmcZEJ7awO8CMEPJ4rLcruw80GCuPRdypVr34Zz6a8xQs6sjidokz5xC1n4eEi9EGNMgmA5WApeBGGLmhPXNd6TcLNwA9oqjs15f2lCdA0EKx5RiUScSQ6endqNOtuNRQz3oJLqQJFinRzYXX4K/ipcgN3I3PIzqeFVvMPfhUkdnyS9Th4U/aFmpEqpKxmzcnGtVZIIOxAwivrwMCNYCeKqnt+ZiOLBQJFTfbjFe9SHepzPRLC0CpaSnWA1eSfjuvgv8W1J/mbAAUbdvr8j3U6AyOZaVb97AxKkdIfjqKUqsUUeCpu7qF+3cRjWIGbBuahUGrFgQqLq++baeizZ2pL3thdvacZ1L6/DO+vNW+rYHO8nhBxxpi2C6mt//tEkVGpmuwe6I1i6vRXbm/3wOTkcOaIYU4YUQFEU/Xlz4wkjcYQWLLEMjSJNKrsrFMfZUyth52j8dfF27DYYlR6qChaQEK+Y/48v9SDw+RX78Na6BlAUMET77kZSZVXxyzZTRyTvBxkMcPVZ5gwtnTecMAovXzUHxxrk9AeyRdBo8ssytP7d4pKC7nAc7cEYFKjfc9OBHlzz4hoAwO2njcN7NxyFuZogxW9PGYszp6iJR2IkTDgTIVhjBnlQoZFNQZLx5Fd78NDi7WgNRLFgQjnO0j5PKr3k+DI0pRMYJkU4w0hY8jUBtwIxGvZa3M+NuQpCGlJBCJado/Gfi47AXWfmJo5C8OH3TVhV24nJQ3yoKHDAwTEIxaU0ggokEkEFDg6/mDcSty4YgzKPHctum4dN9yzAiFJiHBw0FSUxw8q9nXhrXUNGqX2fg0dNsRNFTh6/eHktLn92tX7sUkFIO7n2DhXBOjT2xv0EZ4FKsJxy/xAsd3Cf/m8pmr5Of1crigD4KS+KtYwh71PLn5kCejNIkgw31JPI5bEIYOxutCteRJC9xahl72aUAmhmq+DNs/c2FxTK3ZhNbYPHrwDom+RladMy/JN/HN8GAoBpIx8gUBygAEIscwUroNjxlTQJYcc4TNBe84T243v7NagPDgZwVtpnetNrTumVlgTR1QUMmOQqwkJqGWxMI6KdYwFv8kyAEWQ+J5sAQs/w0/HY9hG4LF6BhRmW8UQaMI3eje+k7qTXh4Q241pmCQZ1Hgegb62dVPNG7LNfjG3hMYBJk6BI2wDJpIKlkApWeiIhWjIefxAug9c1GtMAxEmV7BAQrFIuirn0FhwjrwIYQLKbX5es1obJ5tAi2MWW4WN5Nkp9uVssEES4IkAEIt3pBOsp4Q5EOQ5utn9MxAkGMX4cQ38PR3sYv5RugT8uYm1J3yw1DiM/ZJvDyASjB9Rv39qE6UMLcdL4/Fpt9da+DBlyfWYmS7AvWNxjz58xBDOHFeGIap/+2mdbW3D3e+pUwbvXH4VXrlYbmvUKFEuDpinDeildVa1T+947WgJYX9eN5p4YRpZ5kj9/CCpYPi1h44+IesJoe7Pa9XD/ORN1GXUrk2UgQUizqUJOHuLDH8+egMrCRMJPbxHMIhZlPD4D2UrFMzQYmoIkK2AZKskv6jdvfo9Pt7ZgkqGVj+zLMBOzXtJOR9ocq4uceOPauUmBtFEu/bVV9djbHsK504bgxHHlcNlYvLexUSdYYS1pZTzOHE2DYyj88rX1KPfak5IeZjLivYEoyQjFJVBUQh3PDEbyRIRQUkESIA6OwemT82/L41IUcl0Go2Fjm6CiKEkEK2kdmmkz+ezjy/bg8WV7sPW+k5PEr8zAZ1HovW7eCFynzVn+fYmqeZAp8XDe9CHoiQhYs09Nwtv6kRDngx90BcvtUzMvnn4gWIqioC2eOFnkqD9tmVC3WqUyzmfYykbiDfE4rGBzd+IKBvzgKAlRhTMd/ifoGHo6ZsT+i1eKb8i6zn1BBv8nHou9RUfnvB/5YET3crxu+yNmNb3c95VpPj5WRqkC1N/CimDVO8fjZ8Lt+LTyF/prNqe6Tj6D0IQ70ogR1AE4kF3pj0BvCzNUEmuL52F49CW8UnV30rLnSp/gFu4tCJ31sIJM2seyCDqQuYKucOaAnlQ4qZS5shr/WtzOvYqqzhWW28gFYlyt3lGU+S1D0H3SkrNP73On4R/CeYB3cNpnlIIavCgtwDpuOgDg7Lo/Y7ftpxjddFA0cpJQFd+NV/kHMJ9Zr+6by1zNiRAsBtmzciT73ptsZ9yubj91tjMWi2A6vROz6W2w8f0rBjIquAYv8g9iSt2L8EdFeO3sgMzyHEZmXH/8SJR5bLjjtPySWJ0hbdaRzq3iYQZRV1ozv8aNMzNWsLE0ilyJdj8jZtQUYeERlUky60ZiYcyWxwQZJW4eMVHGovUH8M2udgBq9aNQr7YKWFfXpc8gdYQSXQZ6BesQBFeJtq/EMSABsLHF0niseRNynevvOazEhUvm1iSpvjl4BiPL3KYEBVCrPz1hQd+vOcOL8ODCSZbb6QvsHIP3b1DjE46mYWNpOHkGPEvr3++qY4ZhyS1qd4mVjxOZgfrDos04+i9fgKVpzBpWpM9aPf1NLeo6E95Wuv2Bdq51pVhxmJHwL349D7seOA27WoP4eHOz3ob76EXT9AqYGZ75phYz7l+CR7/YlXEZAjI/6LaxGVv/gEQLsGxx6blsDP66cDLuOWtC5oUsYNPOxf9+uQc9YQE8S4Nn1N/mhW/3o+Z3H+LMR75BKC6p4zKc+tsd6I5g2Y5W7DK0FhuJrtvGZiVXQOJayEXePlWAJBW3nTwW958zCds1v7nOUG46Bv2NH3QFy1NQBFmh4KEiEOMxsCYBR09rHezuAtic1pLGnaE4ronehJvZwbiZfRuIpZO2aI96g4+yCYLlrRiJ34jXokp24Moc9zvo70QBVPU7K30xkoHKxXNnTXQInhN/jtsnDIyhGvGXonMw0c0GSidYmec7RIoHlERgb4ag9hAzOq/bHOqD266Yf+5HrY/gj7YVWN/+CHKt6kjeIVgkHYkQPxFTtdfCcREyaPD25EyWwDgBCYiHrVv/JE2NUcqiMFdMB3EKvQrVnWUAzOffyGxYKsECqx4XKod5oWwQ9f017xOXtFk0MaWl8wP2ROyVQjjLm55R0zNW2k2SluJgKRkMe/BvS46CRGAiKjRol7lRJ+Mpx9+E8yE5S/DbLOssaVuFXzBLURVZAGBcXvsjOUuBLkAOJM92hgM9sEEz6e7nSjXvUb+zN1IPHwIYWV6dl9ntYfQdFQUOrLzjxLyP+yCvHV47i1HlHqzd3wXJKhLLAH12KgPBSrSrWa/72uNG4NrjMlfvx931CURJwff3LICTZ5MqXQxNoScsQFYUFLp4rLnzJHyyuRk/f2lt0n4UGWawrnp+jd4qRv4PJCpYh6JF8I53VAfHDsP+kOPX4o9CkhUwNJW9RVC7xnvzexY4uCTj5VRc+OS32NkSxOVH1QBQq0BDi83JWH+BnDssQ2FGTRG23ncKAOCSp1fq++xLkbV/Y3U91td348czhmBadSHuXLQJL32XUPRt6IoglZu8va5B/3dcVJJmiHe3BvDKKvXz5DyycwzW3jk/qY2RQNbIny3HGcS4JKM9GIffpLUuFRxD55RMIUQ7Lsmo7wybVtBsLIMfz6xCU08Ejy3bjUqfA2dPrcy6buO+AMCWRj/8UQEFTg4uG4N4WMaHmjz9pgM9adWrt9c24O9LduLKo4dh7f4ueB0cZg9LdIDkItGu7n/uHpNsBt+zVMysKcTqfV04akR24+2BwA+aYNEMg/9R56BHYHB5JIaiFILVvHs9Br00D1vs0zDhd8ss17VHMyYLKJpRrQnBigVUghXjEmSNOKy3B3JXfYoE1LJlmHbBPE+ugtd7qLOfcETWNxc5zN6AqBIyUm6S8VZgBHVfaQuPHZHmADkR2JshFuyCDwF4DEl2OyFYMP89LFXtMkAonYibhRswy1GEi7XXiJt8apZWYAjRsK6qyoSwZKlglcYP4L/8w9jZOQbA9abLkNbFNIJFfLH6gWARM2ORNq9o7PFMxw4/iwo+uS2J3CzN2oWcoh/nM8tQFCoCcKRB0j0/WfP+gLtInaVsU7yYFXsMj4+aaroc6y7Go9K5KIMtK8Ea3LEC53GvY2WwBEB+c1iUW90fKpQ82xkJ9qAQQBhO9K9IO2AvUDsCJlJ7scF+LZbJFwM4sp+3chjZ0BtSW13sxNJfz0NTTxRnPPINejN2mSqfnYrxFV4UOLg+tZGt3d+lD8Kb+WC1B2OYct+nqPQ5sPx3agtsasswR9MY7HPgqJHFGD/Yi693Ja4RI8H6y8LJ6A4LqCnpXzGYXGDcJwJyD3xs2R6cOWUwxlV49e/+21PG4mITaX29gpUlqF+6oxVt/hiOGlWiz7ZlA6mwk0A537m/3oDM56WSeBIoszSdRMIAYMWediza0IhZwwoxrboQO5rTn609EQGPLt2NAgeHm+ePTqpsCJKst0naWAbvbtiPr7Vq6PCSRLxUnMEMl0i/P3zhVMiK+pvIspKx4qRXYnI4ni4bi2uOzZyMIDAqB367p8OyRbGuI4y/frIDs2qK8iJYxuuQVH1dNhZdYUFXOgSAnnAywSKCM43dEWyo70aBg8NjFx+BmmIXrn9lXc4Ey8yfzIibX1uPz7a14m/nTzHMl5tfF2v3d4GmgFeunoNwXOq18E9f8YMmWADwoutS7O8I49w4jdSpieB7vwEADIlm96ja19wOBhIilEYkhHQfEjGoyoJLtkQPrNvGYhzbhCKpHeHgHDjd5v2xRsSCKsEyqt+ZobB7C5bbbkRT2wgAS6yXbV6OoVQBRpYOzMOE1QgW2w8Ei42rN0jWoqr4hudSNLS04SpHZgW8qbVPYoP9VXzX9ksA9wEAOJsDskLBRgkQBAEcl3xhMTrByj2INxsWHrXvVbzLv4WWrothrE6IrPqbihFrHxs5rlYCZdZ6PxzajJ5Dzrw+UsGi+eQHK8X0XwVL0kyA5QwEa23ZQry2fxb+7E4erJ0trMQ4Og4e6a2rjlgrHuKexL5wNYDbLRUHBxq+IpUYFiIIBRR8HvPrKLXqZgVa1Kq9XH4qggAQL5uM57YsgMhPwWzD6xFdOTP/dWaDy5dsamorrun3bRzGwKHYbdPl3XtT8cjWIvjoRUf0fuc0fL4tIb5B2nyMgZ3ug2XY/9TZJJahMGaQBy9fNQf+qIDHl+3R3zMSLKM098GGWeBnnK8jLW7HjylDiduGI0cUJ3ViEJS6bfjdqWNR6LQOEF9YsQ9Ld7Th6UtnpBEsYr6bStwJ0SXB57sbGnHkiGJcMHPg5i4XPq62q6eqIpJzb8WedtzzvjqPR87D1PY4IvJjRDgu4dnl+1Dpc+Dm+aOTyE1qiyCpCt54wkhcfezwjPt682vrsb05oB8nnqVx1fNr8PWudjx/xayMJtB8FqLQGxjJnFX+JSZK+I92PeTb4JBkhK1dh8Sgm8jTA+p84Z/OnaRfq6QK2NClPu/snOqNRa7hXAlWphksMv8Vikt6S2W2avqFT34LQVKw4/5TDhm5Av4fIFjk4PVEkoPIQO1ajPSvQkzhcEr8QXyjleQzoXTz09hmewr1bA0gAYyQrl4nh1WCJTsSKi4UReHf3CMYpexDU/1xcI6bm3Wfu+HFs+LJcPmqLJvUeIZCJdWBiGRN2gIBP/4l3AeZp0AV/DTr9nsDQrA4ue8EyyaoQaLNk7lsu801C9/I7biIy/yQZDSiRtsTuXyKphEBDydiiESC4FLktnXRBT4PgkVJGE41ojSWaPtzhhswhd6LlSnzfxKrHic5SwWr2TUGj4lnobBgDqzOGFeBWuN0WhAsRiNYrC2VYKk3PqofjIYJwcpUcdNVJlPUE+8U/4NCPoAu+RoAyb+lLhihKfLROsHqf/KQDQ6HAwHFAQ8VgRdhXWY2FTwt42R6FZwiACywXCexV0glvrmAqp6Ne0QKRzHFuMrwOmk9zZac6Q3cRcnVR3f1wM1jHMbAoC8zWFb+VfngTx9twwcbG/HbU8emZdCNe0UCfiOBIsRDlBSsr+vC9S+v0+W5Sz02PPqTaaguTiQ/SDadwEiwDiXMWpeMEvUkOD19coWlIEGBk8PPtXbLjmAMH29uxjnTKvXAl4CQjtSOihn3L0FHKI7v716QJgNOWihPGl+O5p4onvhqL9bXdQ8owXJwDCKChPvPmYj6zjAufWYVyr123feqPRjTu3HIeZjmg6Xt97GjS/HVzjbQVIKAkGUIwf36N8ej0ufQE2I2NqFemKn6QbC/M6zP8ABqFUk3Z7aY6yPncy4Eq74zjPX13RhW7MKkIdYJgSNHFGPFng5LIRyOpvHVTrV6uqUxXUfACkYST2wGrj1uOIJREf8ymGAzNIWLZifOkapC9XokIi7k2LRppKw0Q2UwFZU+J6ZV+1DmTSz/wfeNuOPtTXj6spk68TKS5EyVXXL/4wZA8C0f/KBFLgBgAtOA+fRaRDrqkl5v/+BeAMAL0kloUootRQIAwBbYD56SUFt0NK6K34o3XBemLbPadSyuid+CxupkdboAq1YZQp3pil9maOUH417xUnxTbk2GSMDMKtb73rh3K2hKQTNTMWDZf86uBnT9QbDsknoDdfjMM0CAoT3SQgGJFTSClVIJi2qeTLFwOinRK1h5ECxXuAFf2H6Nu4L366/Rgta6aEsOdBVO/VuOWVew6l2T8FfxQuwrPd5yObdPPbc8Skg1RTHBBn4q3pKOgeJNlucnFSy6HypYikawlAwVrCLKjwnUPjCBZIlnXiNPZvORvC2ZYBFlPqafxRtyhZ9Sifpy200o5MyPGU8DT/AP46/UI1nXRypYNJ8/GSJD/ES8gCAeVh9iAtv/lWqvtxCSknh4V4zsfz+9wxhYMDmqzpnh7jMnYN0fTsK50zK3FcmygmeX1+L32oyRGTqCcTT2RE1bzmSTe5jNJHMuSDICURGNPVGEtKz1IK8ds4cXo6JAfS4GogK+b1ATDhQFnDVlcNLsx58/2oY/f7QtzYvqYGC85sl12qRB+mvDSw1+jQYRgJe+24/Lnl2lG8lmws9fWos7F23GPZriohFGsQQjFEX9z+y3IM/WErdNlzQfaIsMkhAnLW5720Oo6wzrgTIJzo8ZVYLXr1XVJElenJw65Hx44JyJ2vuU3kJHznsjoRJkGTXFTlQXOUFRCfXCbC18qYa+z63Yh9WaKp0VwUqoF2a/BlfVduKmV9fjmeWZLWsISKWItihh0TSFau3YmsmrW4HMTXIMpbdwnjttCC6ZW5MUeqTG0sO085p8XzvH4PuGbt1bLdcK1kWzq/HOL45KIvg3vLIe/qiI3771fVIC6OnLZmD5707A6PL0MRNZVqAo6j3BSjjkYOAHX8FaGH4dM/gvsLahFJg2RX+9pEP1UPhWmYQT6HXo7piEEnfmzIxNC/rDvtH4rH4YJsrpEw61Uik+lWfijPKJSa9H+GJAAKJd6aagZiAnfjYfG04jWFwWgtVdr95wOx1D0f8OWCp4u6bOJ/ddjeUC+u+IhLvxaWVmn4YZse8wltkEvssLwFxumBXVKiPnTK7w/YW/AW3BOO6m0oNQQlbZPAiW2e/AaNtm7Mkzb6KtEO2KFyZdDElISAhbD2A7HC7EFA42SkA0EoLdmT5j95btXGwUuvFWacrx5B3wKw7E0PcSebNnEn4vXIFhRZNgppc5o/1d3GR7HCsbLgMM7YAcVIJAyJQRJIFAlrGSdD8YiDEOQAI8VAQOr3k2keO0AWxKgixJoC1c5Rm9dTN/MlTkoDGN2oWqgATgGP31btqH/xOPBeMeh/6uL1E0DYZKPEmLS/OT+T6MQ4+aYif2/Om0tKH/XODgGUsDVUDN6t/7/lY4eQYPnGt+BlrJtMMk5jxiaCHmjytDICom+RKRSoXXwSEQE9MC4hP+/qWeJT9yRDH+/ZPkhMCzy/chLsm45aTRlt9pIDCuwoutTX7MG1Omv3b21Erc+sZGiJoCG6BWMJ75phZ720OYZ9JyFhUkLNnaApam9OD+y53p810hzWsotYJlyzDHLclKEgmJ91P1MhuM1R0i4iXKMn5/+jh0h+P67+lz8ijzaPYohDxpUT7xmCTKfzRNGXywoK+ffB8by2DZbYlEJqkAPbO8Fj86ojJjKylJVnAMhdnDitHiTySXHXzm45TPDJZf83Hy5OBpSJITVp1YAPCfi47A+U+swPXzRmZdpxGRDKIwoiTrdggAsGxHG9bu78LUKh8mDC6A28ai3GtDi6bk6eAZXYAMAE6ZOAh9Bc/QiXlultaTLGYg1VArFcqDhR98BUvU5qHIfBQAKEIEHoQgKAxucXyEZ/i/IV6/3nI9RILb6VID2KAJ++/Sssmp/dBxh9rqJvlb0z5jiq79mE7twCC623IxjrTlZTE1Fdr3AgBi3prctt8LMMU1ODH2EG7g7+3TehRFQVdEQABOFLozB56zg1/gN9zrcHZuzbiMTVRJsc2VTLDWO+bgC/kIRJR0YqFXS/Ko9PH2ZCIAAIyoVrCYFKGOTSOuwozYf/FNWXoF1AiPfweOpTeiWLI2qKYoCgFKzRCFesy91mK6HHjy5dxedSomx57GC6W3Wm4jF7Tbh+JlaT7qfbPM95PTfkshIUqiyDJ4St033oTQ8hrB4jVi9Tq/EHcJlwKF+ftG9QeeL7oFANAJL9gMymMUTSOuqA/DuIWFAAAwsvo+Y8u/RbDQzuAd2934u/AAFEOfeZNjNG4Tf47vBl1s8ene49+2awAAm/iphxUEf4CgKAoMTQ3YbzfYp9kxWGTnyVyEWbBuVsGycwz+d+lMvH7tXJRrRrmirOhJKFL12NESwH3vb8WWRrVqZXwO+xzJlXU5hUAcbJB7ccxQPYuLMkRZAWtQD3xzbQP2tmuJQpP9jMQl3Pjqetz+ziacMFYla0YPMQJS1XHZku9bJIEXS6nixQyegwe6I/jTR9sBDHwFi0inP7t8X1Kr3pzhxThlYgWKXOpzWTS01xnb/xRF0Y1rtzb6ccyoElxzzPDEnJZ2fg3R/MAW/ndFmuCIUWDDaj5HJ2KXzcRLV81O+pyV9P/YQR7cMn80zsjBiypgooScCR9tUiuc2XzNJg0pwKZ7TsaNJ+bnfSlIMgocnO4xBwAb67vx3Ip9ekJg1rAifLmjDb9/ZzM+35aId41WAA4ukaiZPKRANx3OBkVREBdlU2NsB88YSLP1vc0omHKocej3oI+QNYKlRBJkxd/VjialCK0oQtSukp9Yj7WzPaNVZrw2Cjcxb+OCyKtpyxzd9Q6uZxahVOlMel1xqTc+JWi9DYIRDe/gLdu9mNP5vuVyegCaQRGPgO5RJUkpX2ZBiL7C4XBgj1KJOtHcRTxXhOISBEnN4FndpGRt1kcWMrck2mX1wWRzJ++TI8M8EADcxd6CC+N3gvblXuvjePI7JAgWq8nVcykEy20w57PC1KY38QL/F4zq/ibr9kOURvozEKzBsT0YTdXDQSffePNpVcgGfUg4w29GERl/MUE6BE1iP64woExudoS48pqn1BfUbLwgnQzGc2gqJ6Q62E1bn+NxrSIYi1m3y0YVG3oUJ1gLtcxMcDidCCoOcJSEsKY6CiRagcw8hvoDpDUy4O2bMfVh/PDwt8U78LNnVmFdXVfGZfTZBwsRjbhIxDLSAyEiwZ3aykZA7lmiJOv37/GDvdh878k4cWwZnllei/0dapBO2mjvPWsCbjt5DPa1h7B2fydkWUHYYFJ8KBIFLhsLnqXBGO57xAzaOB9nJDRmFT+GyFFLCuYOV+dxhxSmJyYztQhmqmBxDI2nfjYD/7pwalILpWnVcQDw5c4200oPITUfb27Ggx+rpK/SZ8eEwV4UOnlIsoKfzKpGpc+By55dDUGS8euTx+jtfIRgfXDjMThrymDsbQuhI5gcPxmNtIkKtBkYXSKfzPOki5SYYVS5B7+cPwqnTsqFYOVewSKQMowKGNGbSuTn29RK6RlTEvu9aMMB3P/hNvzqpNHY9+DpeOPauXqrq8+Q4PjnBVPx1nVHYuERQ3D0qBLd9ypsEoNlwuur6zH6zo9x16JEC+y9mqfX2EEe/RzmWRqPfL4L17ywBpsPpNvhiDrBOvQJwh98iyClCU5Q0QTBaoMP82OPYnixE/fbXwKCgJilusRqBMvjdOBX3JvwS+k3sVOiH2IEV49mXJu8D1pAyEasqxH68po4A2W3FlrmHSTDb13BcoTV1kRbSU1O2+8NrEhLPvA37cGH/O2qmAhOybicogk0KELmlkSHRrAcnuSM3gniVzie3QWlczBQnRwsb1aGoV2Og3PkLmdvsydXWgCAIwQrpWVPv7Fk6REkAghUDoIOvy/6G1YfiOJV5zCY1XYejNyHMlsnmoWTACS+L9uPaka+rk24gPkGlVEZZp5OCZ+0BOmIxyPgoZpGmz3GSFWLhQhFlhNDrIfIdb2C09qEGethY4HiAEQgxK0J1v3uO7CppwfvVWUXvjFDD+2FW4nA39Gki53A34AxVB2KmTJi3b+NAAAgAElEQVTrD/cSa4rOwCedg3Dh6OkDsv7DGFj0hAX87JmVcPIsXr1mTl6f3XSgB1/tbMPlR9ZkXIbELLKCjFLVeqbZpBridXDgGRrnTU8kuFr9UVzy9CqUemx44YpZeOQn08AxFBq71evLbWOTiAMJHkk7YYnbhpoSF6bc+yl6IgLW/eEkbGtSZxVzzZ73N34yqxpxUcb8cYnr9OPNagWizDCTYiQ0ZtUj3VBVlvWWuNQMvyQrECUFNJUe+FsRrJPGq3FLfWei62CgK1gEiqLApVU5QnERT321F1FBSpIfX68R/RtOGIUbTkgkfB44dxLW7u/CwsdXICIkJN1HlLqShDzIebK9OYBJdy/G6EEevHXdkThpfDl+97Y6Q2hFlMixbw3EVENmk1nBvsIfIYbU2StYPKO2ch4zamA8neKSgo5QPGl2K5EwTpxzqT5YgOrfV1HgwPShavxBzqndrUFEBSkns28zo+ETxpahqsiB6iInvm/oQVsghkFeO9bs78KXO9vwk1npYz+kus5kqXQdDPzgCRbtUodamVgi60YkJUs8diicGpgoIWvyQ2ZzeK96Q3QjgrgggTecGB45CFCA05t8gvOaSSkfbc9pn3X1O4d1IMfbXHhUPBtx8PiVxXIFcfXGXVCRWXK0r7BzDP7OPQYXYlDkk0DRvbvBhDqbMIHeD56yvqEopIIlZiZYt8vXwSH68efC5B7fE6KfYxK7Bhu7TkeqOa9eibGYnUlFopKoEgGKpvENMwvfR8sxvSB5ILyqezWW225FQ/1UAG9nXCchIrkozFHOIsTQnqaUSWCDeoxsjmQxhaLOjVjG34ID7WMBvJd1O1aoafsCF3LP49seFsCZae8zxCfNWMGKqfslUOa3GYpmMEF8CSGRwnZJwUnCFwgzcfDyUQAOvpLgnJ6PAAAThe8tlxO026aYhWDpRqe9JIxBpgAQWxDsbAGGq3OfE+pewVW2V/Fdxy8B02m4vuHUWRPxdNyJWXP6Lsl9GAcfChRsbOiBN4+MOEGq/5AZSAuiJCuQFAU0LAiWSdX6kjlDccmc5DRRTJSxoyWAHS0BiLKCM6cMBgA8tmw3gMT1I5DMtLZ/pBpG5kOKXDx6IgI6QzGs2KM+i48aaeU0OXAYVuLCPVr2nYAE5ceMSsxaGat8ZlUHo2jJF9vVJDGRwzYus+uBUxET5bRqHZlzSm0RTF4msd1cPbR6i+PHlGLpjjYMLXaBZWh47Sz8UREPfboDcVHGUz+boRMJK7JHiNHG+m58u6cDc0cU4/Nb5yUtw7PqsQhEBQRiop4cJlWVigK7ZXXz+LFl8NhZ/ObN7/FH+1ZcN08VgRjktVuaV3eH41hV2wm3ncWRWQxuA7HcK1heB4v2YDzrDFZvYTOpKJJOCRJ7RAUJjd0RbX8yx3DZDLRNP2NigVJV5NRJ98iyRCcIa6GW6rWzWHzzsTltc6DxgydYnFslWHw8USrU5SE9NlCsejOjw+btVQQvcedBjrbg8qLhiMAGBxVDMNiDokJ1/YqiwAn1xHJ6kokRPWQmTor9FVXlw/BMLvssZPeBAgCW4/BP+UJIsoKbJDnNnA9Qs4jnxe9BqdyKRTWTc9h678DQFE6jV8FBxRGNhmF35t/2BABRv/rgi7DW0vOEYEE0D2IlWcHn8QmgKODfzmRiITJaH38sXWr/VvlZiCzAUycAOYo/0AyDuMKApyTEhBhsNgeepc7FATGCr4uTgwUHx6CS6kCPYE22iWEzm4MAAskU+TMRLCUOUIDNkbwulpJQQ7cgIvZDxkvUzIwzzK4xJkbUcb4AU6JPYpCbxeIMq6UZHhBFxCUZt0rPwsuF4Mdtfd/fXiDmGwW0LcYe93RYWT8KFAcogJClRTCSg6SvFcJsISACkZ5E9Z3W7CMoW++uv2w4ZeKgfhlKPoxDA0afV8n/s4Le2mcdEOkES1ZgdmqfM60S06p9upqZER3BGBZvaUGpx6ZXUIyBtJFwHFFdiF/MG4GpVT78+IlvsapWbc0nxK3Ipd4X/7BoMyYO9qLIxaO2XW0JW7FHfd5nC3APJjgT7x4uS4sgp7dkKnqQ+wsT8QKKokwTOZcfVYMzpw7G0OLkZ2SrP4pXVtWh0ufAgvHq9e6xszjHQkGyP3DS+EFYuqMNg7RZu8u0aunjX6reTVOrfHj8p0fgyufXmLZ4hWIidrUGk5TsfvHyWqy/K2GZEYyJmHn/Z/r9l7RPkgpgl4GQW+GSOUNx+qQKvLuhEQxN6b/F6ZMrLNXp9raHcM2LazGlyod3r89CsMgMVg5eTal+YP2Nzdps45trG/C381XBOEKwnllei/c2NqI9mEh4GytY3eE4LnpqJeo6w/jytnko9dgwutyNUo8tZ0KYqu7YEYzh4v+txLASFx7/aXJHhe6DZdKdwzI0xgwamOdjvvjBEyybR81Q2cSEX8Hgzf/FStsLWBe5DOxgtarDx6wJ1hJlNhqlKK71liAEJxyIIeLvBjSCFYkLcFNaUOxIbu0rKizCLmUIlEiOhmqaOAPvym5KbGNphOMSYqI5wWoLxtAp2UG5RsLhHFjH+ihlgwNxxMLBXhOseECtJMb4LCaQWosgCexTQURI3DybdrOTGTULJ8XCSa8rioKfUovBsjLEPHuUr8YfEIgBz0kUbIA+aOtMaRUgLYOcFE5dRRJYTe6eEBMrnBT6AJfy7yNaeyUw9edJ7ymyDDulPnjt9uSHKMOqN0AmS4tpLqA0RTww5gp/rLZt1iDjH5eAHrjhsWiDtHE0AjF1cNdtoTh4MDDsnDvw3vvVmHpseoXOiBvd/8CutgjedFnPPD4duQUOPgS7sBRA/tdmnPcBUUAIJKrvxACdcVi3Fx/G/z+Ry4xUJggW4hRGjCpzIy7KmVwj8OMZma+L+q4I7nhnE6YMKdAJlvHuTVEUnvmmFqGYiKuPHY45w4shSDKueXGtvgwJrsgMFqB2rZCAuTMUx/gKL7rDAmYaZNsPNZp71Hvouxsa8a8L1c4KI6kiAh9G0DQFitKk1rV2uFQxIytkmgNq6I7g4c92YUqVT68Ymkm59zdSq6S/WjAGgCqBLkgiOIbSZ4ZJvPPHD7bi6W9qcefp4zB9aCHOfWwFyg1eSakBvCDKOrkCErECqdRtrFfHSXLxiSLzVwxFYWyFBxfOrMLUKuu4jfymQg7H89nLZiIYE3NqOSSdWZsO9GBQQf8/I83sDNwG0ZTBPntGguWxc9iqteX+87OduP+cSfj4l8fmpWZKKo6kAt4ejGN7cwDbmwN48bv98Dk4KABOnlCunxtCbzJJBxE/eILFDpmGudFHUOwpxwfaa3SgEeVUN1w2BnafehO3xzszrwRAVDcxYxClnYDchXAo0XYYCvTACSAMO5wp7XFkUNJ48lmBSMKnijOY4WhmC0AHEIseA5ctPahq6FID+crCgW+pisEGIIBoJIgs9CgjpIBa2RFt1t9d5t3wK04IGXRYgl0tuJV9A2FuEICTk7fBqjcfOZ5MckRRBEfJkBUKLGedvUrFZnYiOmJxxCT1JjAqvg1+itf7yAlsTvU3sstZCJZGWHJRmCtV2jGT3onvevanvReLhmEHVCn3lLZH4olGK333gSEEi85QwZLKJuGc2H0YVFiB/5J9I0OpFgHbP+S/oohvhdAzXhcR4Xuhutcf8LpcOOvCa7MuF+MKEACFbOOIFUorvHQYgV4SRtFeDPgByUCwiDVBapLnMA4D6JsPVq4qXR/edIzl+1b4fJsqBLWxIdFxkpq9f3TpbnSG4vjJ7GrYOSatkkH2b8H4QbrXToGD083B93WEM0rIH0qQ1iojSPXuzCmDMxrNsrRKOogUe2qlaktjD259YyOmDPHhL+fl1sWity+ztE484qIMSVYGrAUNgG6C29yTXP03tnqRmIb8zmRvFCXR3lfkSsiCUxSFuChj8r2LwVAUlv56XtK6A6SCpbX1nTWlEkt3tOGCmdYJsrqOsK5YydAUJg/x4fuGHj25mgkJcansBItlaL3VNVd0DZCZ9knjB+GNNQ2YZJCtd9sS1+bIMrfuOwcAPsN1azxnyG+b73nEa/ELqWAZTcPfXFOPve0hBKIiNt69QBcckUwSSa2BKB78eDvKvXb89pSxee1Df+MHT7AKvV40oRjxcCKIYyNqEM96y8FXTcMxsX+i0DvYcgrldGEJoowCOz0PPbQTkIFYMHEyRbR/R+BIy0UXOnn8nn0ZI4UGCN0TwfkGW+6zUxdnyE6w7lceRRnfiZbAJUBBelAV3fkFXuAeRiPmweg/NBCIUzygAPFIeutdrpDDKtFVHNbffeuwy3DR1tm4snwYzLppI221uJFdhL1yDYC/JG+DVQN0JYVgxWMRcADiYGHPU1mKN/QHC4KAN9i7IDMUKDY5ILe71JuTLYshM6uoDwfWlt2ElrJrN7xoumJOLBJSCRbFI5X6MKx64+6PChat2RhQrDlZsLl92KCMxGg5MVQut+3CS9wDaBdGAJhn+rkRyn5U0i2oDXSDoRSICg2W7btv10AicS5YMyy7Nhtnz0NQxYhtw36G39bPwsLiaSDi+Lzu/dbbFMdh/L8MxmI2IRvIcHhvFMie/qYWi7c044UrZmFdXRfiooyZNUVpapfd4fR7kZ1jsPx3J+iJGEKoNtR1g2NpjKvwgGdVH5xKn0MXEqoudmJUmRu7WoPwOTlMGlKA11bX46HF21FZ6MBZU6yfwwcbs4cX4cXv9ieJXJw4rhxf3Xa8pSfmmjtPAktTmHC32mh956LNeOPahHBOZ0jN9BeaBOpr93did2sQ04cWYWRZ4j5Ekl92jkmaQ3pv4wGcO22g3DSBzzRp726t3bGuI4y97UGdOO1uDeqkmZyHRpl2os5bbGjvYygKNAVEBRkMTSXN8FwwowoUpRr6EiJZ4OTwzGXZ51cf/nwn3l53QN0GTaEtEMNDi3dgeIkryQw3FUavr4FAfwlspGL+uDJ8cOPRSYbYRtl/cv6MKffg/RuPzpiIOdBtHftkApciymUkWBFBSvhgMQl1TjOFZH9EwNvrDmBEqeuQE6wfvEx7kYsHRamDrqQf0661A9p9FSgqKEC9Uo7GsPVJeQf1LB7inoSNVtDNl2O/XIZILPEwiEQiaFBK0MakmwEyNIWj2W04ntmInpb0KkMqLlPuxmmxP8GZg+pfnFJvJELU3HNHadmKY5lNGEkdyLquviJOq8F1PBrs9TroqFoVpJ3Ww8cJ9SPzIDbSpQp7BDmT9ZCWtBSCRWZm4lkENsxwufwO7mWfhdjdhHBIbUcNw54mP253qSTYAWuPpNud9+KY2D+B0v+PvesMk5u8uudVnba9V697b2AbcAFsOqZDTCdxKCHgQAgJJYF8hBAgBEgChAAJNZQAIaFDQgcbbHDB3bis23rt7WW6NJK+H9KradLMbPHu2t7zPDysZySNRtJI99x77rnpbwCMU5ckMGFrggUAYQufPtao0nFa1ya6W+6DSofmWhMs02UyRmag+pswm12PMcoW2+1GjOs7ZMyxk3phKPL+xkL/k3iJvwtcg70ZhixLEIgCRSPguzDUOhZiXjnqtGI0hqL3LtGojIruwQrWIJJBk8aa4fLXFcwaUYiTxpeknA1kh9++vQFfb2/Ff1btwW3/WYcfPP0N9nUmB1qa1aRh6OYKRQbxoATr4U+24vtPfa0Hx0aw/e71czC2LHrt00A91yngwunVuG7eCJRkO0xL84GE+RPL8MzC6Xj3+mgF0CNy4DmCcESxDchznHwcUa1rjX+u+VOMbvjXijrc/NpaLNse3yJB5Yb0OXv8WF3pQ8nr/gIlvZcdpfcu/2PpDvzg6W/M92OrcxPK9SQS5X+qFn2+5LkFPLNQJ0kMiRlGrGpm0F1T4MLvz5uEmSP0PqiuutPGVk4ZQsxBw1SqZwc+Zr5XOnzvsS9x6ZPLMhpKTB369oc8ENArgRMqcuKugRk1+RhuEK6RhslEW0CCYDH+4BrDBIT+v6sYVuTBfedOwjVz9R7DVn/0OAek6O9D4BiMKc3CnJGFcckKiqhNe//TmwO+gsWxDB5wPIUKpQ7tTRNRWFoNj6zfTNz5ZciL0WXb2cpGIgqcRGfLvOjEs1V34a3V9fhz1gRzmTaxHCeFH8L0sjy8arEfXqMh3de8B4Wj7fdXVTVslXKhablwu9P3ZUSMqpEs2QTs7foMLOTsvxlYFDIjAgogh7pfwdrIj8P2SBvKi8alXE6IkS1YQerQCVZITH6QKkIOmrQchLT4Gyq11Za7EcSfqHyGGm4Xan1NCPEEOQCCxIHE2oTLoz8UXFpQj3JsKmUNShZ2a6xpAZ8KnNGrx8nJmvEAn4fTw3ehLFvEE4nrGXI+Fj0nWETVt2EnEXRpIdzJPQ0xyAGYByCaFIiw9r2JlGCF/Tp5lAjfjW6lvsWwSC0msBuwOoVxTjDgAw+d+Lq6OYcn38hIx0pC6Ow3Rwb9m4M49EAIwQXTq0AIsaEy9rj9tNT3ZIpj//AJ6ttD+PymuUnBXoFbMCsIVtLghbOG4vmlu3DF7KG226f9FXRGkJNn9edBOP554A3JpqFVrosHwxD87MTRuPLoYRnZXvc1CCE4dnTyeIUfPPUNvmvw4r0E8phqO7HwGRbaHjGZQERdBOOfo1JMsGr17/2FxNlXeTGVqAK3YH7+iGIPrjxa75+PHSJM7cLdAothhfrTl2FIXFxHk7L0s8aVZeHWU8bEDcPNBLEzzFiG4H3DZt+XZsaladaQpoIVjij4ZkebbqCRgaU4lf0yfTjXjWMZdBhW8iONClZ7UIamaUnX4S9OGo1LjxqCspzuSfyLskQsiJFttvqjBQ5fOAJV08k0yxBcefQw8/pIhGnTPjgHq3cwmWzFcGYHapvqUFhajRxVb2LMKa4EzzK4x/Eshii70dE0EXklyaXdcDgEDoCkcRAY1vT+j50HkCpLBAAhsRCIAKH2+pT76pMi0DTdHMHKtCIRshGAKmFrguUI6JUrodBqQlLvYocwGk0hDtnoQgZFDgGaChhueR9yx+CLyHg8U5W6RF/d9Ck+F+7Ejj1zADyd9L7i1bX8siPZpWfjsIW4eOORWFhUg7mxu2Icw+4QLHoeIlIIIb9OdMIk+TiIooi/KGfBrwr4qRyBIFh/VkiOSjTSQXDrmSvqPhmLoMpirTYMYUeyDI1x5eLxyHxExFxcm/ZTUuPBgjvwZWsDnqqaYfm+yBNcxn2AgBolU4rh4hhh7K+XCMPrpD2gE6zunJu+hsKkH4JNK4shInabMJaq+/AX/k/g9hYDeAEAcD25BSTUhkcL9n9CZRAHJu49d/+5yQJ6Zl5S1DgjjaGFbmxv9mNEscfMNFvZvQ8v8mDzXaekDOTpevT5axIsxMuuYgt0sffRgUiu7LC1UbenB+ylmde8sALNPvu+m1Sxid0cLCmhP5YOQWb3c/BON0/JB5U1LphWifvOm4zaJl0dE+sOF63KajHmUpw5VJgG0gzRrwn6bPWHI1i3pwM5Th4/OqbrVRVawZo5vABXHj0M/1vfkNF6mfZgmQ6CDi6jYdg0maBmMGi4t6ComllJon3+UkTFNS+sTHL2I4R0m1xZIbaCRR2UM0kA0ApWJqR1f6P/a2i9gACnB6CB1nqo4QA8CCCsccjP17NFhzNbMJPdAF/TLsv1TZmVIR2jMwliMxW+NARLdurSQakj9Y/Q39aIv/B/wq+4FzL6bgpDA3trgpUd0rMqWSX7bwYWxatFi3CZfCuaPRnqWlUVOx+ch7Z7x0MyKhRUV2ulF4+FiAiqmSa4JWu7c2LMNdPcyZJNqlFOdMWRFGCTWoU6tutWtBEmSrCkgP4QCDPJNxNCCB5jL8KjylkIpkh03SPdjUf4P8PFppcGiFm6E5YjkizNDKWwAufc+bgncjGewtlpPyMdwhEVClgIvHXw4jTcEx2QoBmBl2JINNUMKlgdcKMm9AIucCXW4QYeFMPhUk0xBFsK6t9dIpk5i1oh18FgPvs1JgaXm6+tkcrwjTYGHnf/DFAdxMGL3a0B1LUF0hpkWBlp0ICdZxlTGmVHGNIFSdQOm1awRJ41RwfMvPdj0wQhx8njvvMm4dGLD9yZbR0xDwnR5ris3NmOr7e34rUfzwSQbGBCYxNPSoIV/yzkWYJCj2AajFDzAisjjt7Ev1boipuHPtJl4zQOaDN68+g1U9cWNL9XVP4XNblwiyyeWrIdEyty8MiF+vmn12VRlojb5o9FSY4Dpz282LSA7yro9o4fW4K5o4vNAb9DClKnzHKcPL7+1XH4NMFsIxGUYGWaENhjnJsGC+nt/oKqachx8ijOEsGzDM43HEL3xz54QzKe+2oHXvlmNwDg8Jp8nHtYpbEf+jL0+gjJClp8YTO5EAtqfDFYweolBMUCQALC7Y1oC4TxqHwJ8oQIFhlBp5/LAyTA37rPcn3JrGzoP/ZjGp/HNeLTWLPtB8AxdwMACre/jZXindjQcgqAvydtQ3MXAc0AvKkJVqi9EfPZr1GHzBpwYwP7pM/UNBQqDQABCiqTZ2P0Nqz6bFLhu8/+idHB9frfqz7G6Nlno9q3Ggphke9M7UTF8HrVg1WtDRqokQmTlSy5MPczweYt4CzDqdLvMTovy3Yukx0o0VWkIDRN/wFLFgQL0B903lAEPimCHFfyzVOLSJiL5VAYAsWRvhroyK/AG8pMtPJVGJnwHmnejLu5vyEkjUGiyQkNVNJJFTKBOaDZxiKY5wW9AkwikKQQBIfLdHFUWPuslmoc13AoBMANhus+Iekr0H1ORbD8xIE/Rc6Bx5OFK7r5Odn5el9EtqZXTKWICimiN3J3xap5EIcWNu3rhBRRMa4sOyOVBMVpDy9GR1DGt78+IaWzmZWRBg3+OoKyaU/dHbMMQDchyHPxZtBd5BHxf6ePxztr9qLRG44LnFJZwh8IiJVR2h0v+n1pRSWRLNGqjmUFy3gWJlawzpxSgTOnJCcaiyx6WnoT04bkYfnONhwzSk+MUmt9KoM25xupGh76aAt+eepYHD+2BCXZDkyqzEF5rhNzRxcj3yPg0r8vQ22zHy5DGqlXgTQUuAVcMWcYsh08Vu1qx7o9HXhrdT3GlGZhZEnm42W4hETCKRNK8eKVR2BcGhknwxAUZ6V/rtMEQiZDhgHgj+dPxuebm3Hy+L6bU8izDN5cNNt87h8zuggvL9+NQk/vXyfeUAS/fmM9ynIcWDC9CmdMLscZk8uxtLYF7QEJfkkxEwZ//mgL/vrpNvzipNG4dm587EslgoM9WL0ExVkAeIGItwFNYRZPKqdiZJYHi4z3w4JOsKTORsv1qXQsbGTTRY5BLvGDCbeby2jBNuQTnzlzKBFctn7Rs4Emy/cpaDN/kMlMDxwb2Ceirb0d+cQLSeOQXbB/BwQCgJtTkQNfxiYXf9tAcL/xt3fLF8Dss/HH8B1wiDK8wgUp16UW46xqHcR2qgIatVzwOclEtarlS3wl3ozte6YBMR1zPdGZm+dBDkExZnPJrHUmaxq7BRKzF6GOiUCuhSQ14IUDgB9OZGcgEXQXVuN6eRFyeR4LE94jHbtwEfcJ1kjJ8kGeUXEUsx5OBUi0su8qftZ+N3KEvXD7nwZg7QAZgggBEYQCPoNg6desauM8CAAb3DOw1pcNCXqVzo7ADSRoxrWgRewJlpdk4U+R8zA1O7fbBCsnrwgRjYGHBKDKYfi9PvyeewIdXD4IObWbWx3EwY4Ln1iKtoCMlbefkHaYaiyi0r70g4YBayv4xVubzXlaqcYzpMIrPzoKsqJi9G3vQUO0qT8q/Rn494hMwXNRsmgnaaKkg/4/lNBPNbkyFxcdUY1JFjbvZgVLTp1ke+GKI/D19lbMG5OcsOxNPHHZNPx3/T7T7CLPSEAu39mG+Q99gacXRlsH6PGYXJWLyTGzp2hwLyYkUn95yhhoiF6f9NiuqevAT15aheuPG4kbTsicYLHG5//5oy3IcfFYMK2qVwdXRyWCmVWwzp5auV8dHu1QFTMwnA677o4RTjrY9d0vuWUeNE1DSFajs/poksfCSMQlcDisOhejSvtf5XFQ3Kk0t35T0PxNpk41lmHLDt0IIeK1JlhSOAhVI6ZciTj0DAUjRYmEFjb+FqxPGlc4DJ8rE7GFTS3VC/t00hbmMvuhP198M6aHHsXewqOS3qtv6cBLkblYLMwG+oCtn930KFY7rkLV9n+lXfarbS341+5sXCXdAABwN6xAKOCFg8gIazw8ntQ206yQuoL1J+cizAg/Cgw/Nuk9gQPKSCvcclvc66buvFsEy+i7kYKoz56KU8L34PWSRZbLXiM9jceFP0Fp2mz5PrX8D5DM9MpUxtFpNJfGwqwSMckZJY5oeEn4HR5j7s3oc1JhqLIdU5htEBj7B3XIkMOFg/pvpVUow7vKjJSS0sWFC/DLyBUIhGW8JfwS1/sf7vG+7m+obHqCFW08734OS+BZtEO/T/haGxDsbMb53Kc4A190e5uDOPjBdnPYcNSmPbW0JjGzDwAXHaEnklwCGyMR7L5EZ19HCKoGlGQ5IHAM9rQHTXk5PwAy072FWBJq91yihGH+Q4sBIGl+04njS3H32RMtDTTSufFSzBpRiBtOGJVRL1BPkO8WcOGMarPaFmty0ewLI8fJY0KFHn+lq0C0GHNHb39jHQDgB7OGYuGsoWjyhvH6qj1YvTvedberybuFM4fivnMnwReO4LmvdnRp3SufW57WHZD2FWVawRoIeHuN7jFQ39H7UlI+wRxkWW0LNtR3QlF1Qw2nwJpkNNU9bmJlDv59zSzcdVb/z8I7cM5sCrAevdzMBZrhr1+L05kvUSJEMyGqS886aD7rfh6vZyiGhZ/H1AoP/gOAc+hBDSvHVGqMCoFmQ7CE6mlYIN+Kw7hcnJViX+WAHvTLXGbsWnIWoAlhhNTkU7XdL+DWyJU4qbrE8G3bv9CM+VKqnaNhDKjWunTCXGDzHxALoskAACAASURBVFET2ojOpj1wAOggWShOc/M0CZZm3dxLH7ZWGVremC3FKfGySmfdYmwRf4B17YcB+DDtd4hFh1CGTd4qhIgDXk3ERm0IJniss0ky6wIigBywnhQfMvrRQhYmGVbgWQajhGaIcid8gSCyYtwnI0b1VWGTt8UbNu0CUaCpapKlfFfAGbO0eMGeFEpEBDQgbPSobc0+Cg/IBVhUPgLzbdahAYYWbMdEZgc4NfMMY3+hwTMWbzfuBSfay3yVtt2Yx6xEjTYWwBHd/qxOJgeFWgc62xrgN4i5jx20aB+EPawIUDpommYGNukIjFUFy8VH3eq+vGUeZEXtUQ9EVb4La+840bzP3/DPb833rMwzDlTwGUgEY+3ChxW6cccZ4zPe/oUzqnHhjOqkquRjn23DM0t24Kqjh+GHKRwd9zfyXQL+cfkMXPrk1+AYBiLH4uiRRVi3p9MknOvrO7CmrgNjSrOwalc7tjT6cOmRQ8zrddWu9rhtrqnrwE9f/jbps6ijYqYozXFgRIkep7FdfHYu2dpsWovbEeeSHAfOOazCtKM/ELBkq+6cu6M5kGbJriN24LWmabjkyWWQFQ2bfnsyWCb+3HFdsMLvTxwUqSBSPAbvKdOxkRmBnB3/xcPCIzg29LH5PuPWCRYTtLZV1o0CCDg6N8hlZFAiUTtyWs0iDusAkPrxp5uRoPj1m0GEzyyQTJWB2mXMw6jO7xtja3PIrJz+xzWy4W0sZN/DiWNysRPlcCKM+m/1zicfk/67cwbB4qwIlqah1cheFVgQLM6hEyw+QV6oyCHwRAFLuv6jfLd8EU6Wfo/dBbOiVrE21YmIIR2Ug8myPQBRF0Im8/P2AnMH3hJvg691b9zrqqwTLM2CYBGGgWxY1ctyz4YNCxodY2BPCrezQ7FKHYGQcdOjvXqpBiMWoQUTSS0cAf17KczAdwDbUHoWFsnXY1tOclWZwl3/JZ4S7sep3pd79Fl+TpfGBNoa4N29AQDQ7qrp0TYHcXCDTZDPSBEVD/zvO6ypa7ddh5IlNsHy2gpXzhmG/zt9HEqyo/cCWh0IRxSUZDtQmefqdjXkZ698i5n3fIT19Z0YUqDfy2OD1IOJYMV+LztJZWxwbzXLaUN9J1bvbrds+OdYxlLy2RaQsK8zlHE/9f4CwxBU5OpJOy5h0Cwllp9tbsKt/16L99fvw6ebm/DS17vQ0BlKOl5vr6nHv1bURQ3JEp47diYiqUBnyXX1ksvESfCw6jw8uGBKvxLcruKhC6fCI3J4cMHkXt92bAXLG45AVjS4BRZXPLscNbe8g/G/fh+3/nutsSy9x6m4572NmHv/p2ZPW0RREY4oXUow7S8cFARLqDkCP5ZvwCvMqYBflwFqnhLzfSV3KN5XpmM7n2gRoCN2qjkACG49oyDEEixZ/5u1IVhFWSKy4YfHWwtNsQ9mFUOmqFq431lhZsc7eJL/A4rrP0p6T9qzFiNIHWry+iYo1QyrdRJJX8Ga1/E6/o//BwqVZrxWeTOOC/8BS5r09QNc+owNk12KxyKn4V3uuKT3wu17sBwX4x3hl5b6ZcGhfw6vxVewqCkBNSnoCqIBhIqS+g9xH/c4JvmWWC4b4fSgQA1ZEyzJqGzZmWRYIWD07AU745MEWpo+pwj0azqSwlI8E/AwbFJF+32+P+82nC3diU6XLhdiA82oJI1wE/ukw9ymF/CWeBtmdOrkW+nGuelrpJvRBgCace5VvmuzVxKx1zkCbytHoBk5UBs36p+bZ30fG8QggGigSu2cl9a24OGPt+LudzfariObjeHpI8mzplZg4ayhpiGCrKj4yye6U1tif1B30OqXUN8RMs0bgHgicjBJBJ0Ci1kjCnDapDJbYnvMqCJUGhbZu1sDWLGzLS7hetvra3HmX5Zg415rxYQV6L2rO6Sjt6Go0WtP0zT87Yvt+r+NgJu6CGoaEDRt2tmkytDtr6/Dz19dbVrOuxISoF39rp9sasSNr6429q1r6ybK3Q4WnDG5HGv+70QcsR8GebMMAcsQaBrQ2KnHDHluwUwC+CUFG4xrPCoR1PD4Z7XY3uzHG9/q8sX/bWjA6Nvex6IXV/b6PnYV/f/r6gXQKkazLwy3T7diZ3Oj8q1A+ZG4Wr4B//Ocabm+q34p3hFuxaUdjwOIDvGkQz2BaDWLdVrLc9wih/fFW/E+dyO8jTtt97VezcNXyjjI+aMy+m4l0i4cx66Cy5u8zeN2P4QPxZswKbwqo231FISnBCt9sO5S9ADTmV2AvLHHYJtWAWb3UgBAmE8/JJXLLsO9kYvwMpMsLutsrodIIhAY1fKhJBgzocQEgqWYBKvrhDR2YGNex3os4D5Dedja/lUxjlPExgzER9z4UJmKWkfmUo8gqxP7YGdr3OsarWDZECyZ6A8ZWeppBcuQCKaoYDkNEhoymo5n1z2BxeJPMbbxXdt1NMM1UFT035dVL9lAg0fzYwjZBy5kLTkGADVsSIr5njXaLh5+IxbJ12ONVA5nu3698aVje7TNQRzcSHT5o4WkVJK9VMOB0yE20dDiD+PyZ77Bz15JlmhlChrM/vCZ5VhWqyeUaMb6sOrctBW2AwnZDh4vXHEkHrnI3mr+llPG4PfGbDNfOIJz//ql2WsOIKWiYtWuNpz1lyW4/fV1ca/LfTRYOBPc99/vAADbmvxxr9NzTmdzqapm2rQ7BRajEhwB6fVNR5dMG5KH16+dZfZ0WVX/UuG7Bi92tuhqna5yeiEDCdvu1gA2N3jNysuBgv35+3PyLJw8i0bDBr7ALcSNoBGN+5NZwYrpwaLEOhJTje9v9P+vqxdQlCWiHM0o929EZUDP0hWMivY90BMUsCuHB1owntmJYlWvLomFQ3C//D08T6LB/afisXhAPg9Kkf20+w5Wd1frbKqzXeZ9/nhcKN8G/+hzM/tyxgwhq4b6AkkfMpxXOTqzbfUQDK1gyekrWB5NDzDduUWYMVR3iFss65n3gCf9UORUVQJ/iy4n83L5luuKbv3G60ggWJpBDLtTwZq790lsFi/FxNq/g5GMB4FoHTxrtGoRtq5gNXjG4gr5F3iv+MqMP5+aooR98cYdXiYH69QaBJxlluspRptlTypYmqpCzKCC5eRZsFAQCuvXKqPo1wmTom8LhmGE00hmaOzAr2BNavgPPhN/hml1z9kvZEiKNZtrJFNMrNCrvWvq2lEY0jO7uUMm9Gibgzi4kdiDZcqVIvbBnktg8cIVR+CxSw+3XYZiydZmvLaizpyFEyuDavPL+GhTIz7fbJ98yHT/ASBkVlr0Z/hlR9V0e7sHMhJHjsRWClPNwQpKCr7d3Y4tjfHPosRBw/2J2B6qWFnpnJFFxmv6v1Ut/pq+5lh9ePBh1XrClla66LHJdwuYUpVrDr/tagUr9jrsarDOZ6By+PNHW3DiHz/Hu2v32i5zqGHdb07Cxt+ebFat8txCXIsBdYY8ZlQR/nrxYbhoRjSWpA6HdA5WJtX4/Y2DwuTCwbN4X7wF2UTPNjRpORg+LCqjcXEqKtCErIC1YYJpJ20E3ln5ZXhEORtimMFvjGU+JTOwXhmDE4rtyUyAzwfCgK+l3nYZ2qOV8bwJWplIqBqFw0GUqo1QQFBclVk1rKegBIsGznbQVAVZmh8gQHZeEQoFAb85YzxamwrwX7kAhx/3vbSfJUDBTGYdsmQGwPFx74Xb9XlmAd6aYDmz8vBw5Cz4iQe3xLyuGiS1O0E8yzIQiAJEQiBULipay7+oEYom+S3fTze02goRPgsIApFAfB/Fivz5uEoai5uGjLY0OpEpwYpYX/sZfbaq4mVlHgSiYAFvf+x+3HovnnZ8hJU77gfGXwnGuGZZIUWvmZFAcGr6sVIPgAoWMapuRLE/psQgWIzYM9OOSZW5yIUX4o4NWK3UoB0O1AwbJFiDsMdDF06FHNHM3tydLfpva+2eDtt1eJbBrBGZWVA/9tk2fLGlGc/9cAZKsh1xMqirjx2O99fvMzP43UFsjxXtz8lElnuwoqEzlCT/C8Uki/0p52BFpe2x6Imjbm9jdKkHzVvDmGzYzDt4BiFZRanR40eJk6ppZnWCY0hc32DscvTY0O/2yEVTEZLVLs8OjCVVmVqpUwgZ9GDRylVXt30owM7Cnh7XIQVusz+Tgg4jp72nXTUm2R84KAgWALQzucjWdIK1yzEGRTGOMXn+7VjiuB4726oBnJ20LjUKoE5sDp4BzxKEIypCsgIHz5oNpKmC4pBYCISBcLt9RoLprIMDgmmKkRbGPCgkVLAadm1GNdFQT4pR7si8l6cn8Jccjmul61CeNRqp8py+zjZkEQ0+zQmPoAfk359ZA6AGwJEZfZbIyHhRuBsBTQTwi7j35E59mLPksA4IHA43HogsAAD8QtWiN0pZD4i7VSWJIbpsxJAN2ATPm2suxPWbJ+Pc4rGW/nERXyuK0YYcPvOBgQpv3ddFHyZOG/nDtcLvsNcr4SWx+/M7wgpwW+RyuAQWC1ItaEgvlbB+fOgMM1a0J1jUOGWPWoj/qYfBmT0V022XHhjIhGBxhgMpY9OzmSlGFHvwpvhrVMsNOEW+B505Y7DEmZn75CAOTYwpjZex02pSbxka0ECWBrhUBlWe40CuMVKC70HgHhvY0t4jOp3ijdV7sGD6gT1cuKu48ZXVWLy1GSOKPdjaqN9XYglTNDZJfgbESttj0ZOZkL2NsaXZWLK1BadO1FUYPMMgBH3mkRMs6OWgaVq0X4tl4BI4TKrMwYhi6vRHBzHr360jIONX/1mLfLeAG0/susqHVkAuObK6y5bfI0s8OKw6D3kpBnZ3BvXzljVIsJIQm4RWY8wqrJw2d9w7P258TSwJ72/0/6+rl+DjosNP/YWT4t4TXPoPUFCtZVIalU/RwIkQnCKuxbnM5/D69Ozf9OASnMAsh4dJYWBh2MFHbAYaq6qGF6XrsMmxEIV8ardBChqAEiV++bY6XbfcIuz/AcPmvuRW4R31SGxiUzfZ+9r1Ycte0n15lGDIygQkH2/NpxMsxWlNGhiGwGWUlWODit3ZU3CHfBm+y082zkiHaFAdBqfoBIJzWn8/3pWHZuSgM2JNxkfWPoevHddiXstLGX8+lR2q4fi+LkmSAGimQUsimoVy1GlFkLTu/9TDxjFMJ7FQDRt/zZjNRW3yuVQSQU5/AK1UR+CXkSuxscTO0H3ggBhJD0a1J1gsrXI6e0awWIZgt1OfIzaJqcWwop6ZZgzi0EOqLDpFsy+Me97diL9/UZt2WS6hx4tWQ3iOMT+rJ8OA2wLRez69r9HZT9Qm+lACJQ6/OnUsjhymqzboPTkcUSArGniWWNqQ27kQnzKhDIvmjkjqY+oP0FlY9Lx7jeB60149mUh7fhRNw6gSDyZW5MDBM/hscyPW1HWYJIZKCRfOqsH635yEK48ehheW7cJbq+0VRanAJEhtu4JHLz4cvz9vUkqlkjd84M3B2t/44TPfYN4Dn+LwIXn44IajsWjeiDiJIE0IbG304ZGPt+CdNXoxgxBiykvNHqwB4DZ60BCsoKDfeK6TrkVo2tVx74mG7bqoWZMa2psTa3V9u/YYHhAeg9+Qo/1SeQx/Ex6Em7EnRoQ6FxoEIBFt7a1wkzCCEEwjjXQgPCVY8eQwtG8LAMDvrs5oO70BZ8LkdDv4fV40a9noZDP7jlbgeAGqRsARFRE5PpBlAnpGVvPYT52fw23EyczXCPijFZ99jhF4RjkZe/O7XiMxLeoVCbxRweJtgmeqhbeyzQUAUOmgzUw1K2yqOh9nhu/EqvyT414/d/fvUCteghEN1kYSZjDUg3kRUjiIyWQrRrN7Ui6ncnqlSjNs/DmzgmVPCly5us6+lOjmHQPB1SodGDPpYU+wHsm5EUeFHkawuucT6gJGwuh4ZiWGFw4SrEGkxhOfb8Ot/16D7c2GcUwGAWKLT8Ljn9fi5W92p102cQ4WJVU7WwL480f6c6kn2eNRRkUi1uW9wqhkleUcetXbWEJLCSet0qQbGWJWsBIkgqdPLsfPTxo9IAgWrVB8vrkp7vXNDfqz+5IjhmD7PafirrMm4vFLp+Gtn8xGWY7TPBY0iRorFXSLnElcdrQEcPHfl2JXS9dmN/XGszMVTBmcc7CCRbGrNYDaJj9YhmBkSRYqcp04bmwxjh9bjGFFbkyv0eP8LQ1e3P+/zXhz9R4EJQWvfLMbTy/Re5QVc55f/xOsg4Y6y44CwA/kEh8mDouv6jhchukBbBr9jQqWxkdv3kHGAyitCHa2QlE1uKH/OF1ue4txLkeXfHFB6wbf9qY6FABoJ3lwZjgjRPJU4UNlKrx8/KwE0qZfTGresIy20xvwRNrxI/YtZPvyAMy0Xa7RMQzHhx/DjLI8vNLdDyMEEjg4IEMKB80ZZQDwVdZJeGNvHiYUT7Vd/Q7tLygTmlDXfgGQr1c3eyKLMKsWShg7mQpEVD+cHmur/RL/d3iKvw/hfaMBPJH0PmPIx0gK4pEIJWcIVmt+TFXjrz9GCYMhGjjOOlN2pfQcsvidIG2VQGn3Zlco7Xvwhvhr1EdKACy0X5CnFSxdcksrxrzD/nsOPeJ0XLK4HXVqPiaQWuQo3Zcy9hWYDCpYLbKAvSiA09PzocDOmulAHXACuwKi+iWAwR6sQdjjww2N+HpHK86cUoGhhe6M5kaZs4cyqDzR7VGC5RE5VOY5UdcWxMebdPVGT6RnE41enFMmRCXUEXP/+j9o6mvQ77y0tsWs8lBpeLaDw4c/O8a2N82uB2sggV57GxL6zKhTnJ1rHSVALT79Pvzfnx4NINqnE2vgsWRrS5ct0ws9+n3+1RV1EHmmyzLBhs4Qlu9owykTSi2/AyVYgxWsKEx7+5jrdc7IItPwhILepxo6wzjugU9R3xGCwDH4wcwazB5ZiD+cNwnDinpmMNUbGPjp4gxBnHq1pEb0m64xFE5DIujQpKiYOwb1jpF4MTIPrTnRwCXE6uuEvG3wB/wQiAJZY8HwKTJo1TNxqXQLnnVbB6HeJr1U7bUxZ7BCR/ksXCH/Ah/mnBP3+tPOhTghfB8Co5J7yvYXXEoHbuVfwhmB11MuR91cclPojzOBRPT15XA8MV5GJuEJ5XTwJfa6aono5ykciFawCtrX4jz2M5SEd3R5X+h5Z5Qw7ud/jDOlu8CUWtuse0gI89hvURNcb70tQz7GODIPvmlVzJdQFWONyqZdn9OUyBqcwn4Dzd99aY0U1veXng9bGPb0MOak/V64FpdJN4MpsB+k6Mkvg1Q1Bxewn+Jt8TZMaHq72/vZV2ANgsWmIFipnL26iqpx0YHGOeV9Y2hzIIAQkk8I+YAQssX4f57Nct83ltlCCPl+zOuHE0LWEkK2EkIeIobGhBByByFkDyHkW+O/U/vqO/UGEitMtFH8vnMn2a5j2nZnQGCiM2j0dcpznfjzBVMA6EHvvDHFOHyI5anICBW5Tpw/rSouqPrMqG7sbk3vYHuwgdrWP7l4O4YXufHudXMwa6SeiOJYBiOKPRhXbj8+5rzDK3Hm5PK415fVtuCT7xrROQAswq+ZOwKXHjkEr16t3+dmjdBnLJXnJkvLZUU1+22W79Qddd80JIAOnoWDZ/HMlztw/uNf4cON8a0aXVVHHDe2BA9dqCdx2wNdO06apuHMR5bg2hdXYmtT8rgWTdPQGRyUCCaCJmaeXLwdN7z8LZbvaLVcjpLrzqCM+g49BpIiKjqCMkYUZ+F706p6dA/qLRw0Z9bD6wf8eC55/oYo8AhrPEQiQ5GCScHoOs9ReDZSjl+XRi3YJS4LkADJ14qArx3ZAALEiZwUlae8kgp8oU5CldcJTdMgRRRsq9uHcUP1mVyhNv1GEBIyH9Jm16Ra265gi1aJ0sqajLfVU0QH+Ka+2VCCldPD0rcMfX0pgWC1+HTpWYHHXt8cZpyACsjBKMEa3fw//IB/GUvb3QBO7NK+BAom4A75MuR6xsHfat9UDACCUTEVFWtJAjXJ4B2ZZ1hKg1txF/ck+IaxAKKVKNNIwsapTzHmYCkWLoKqqqHJF0ZJdmrZjWTILNMNRjZdJg2CtVodjn1qBRye1IOl54wshFin7x/DDXyb9mDxVFwi3YryoirY1QRv8t8P8EFkqZMB9EyGU11WhP+Q41Gq1GPE6Gk92tZBhlsAfKRp2r2EkFuMf98cuwAhJB/A/wGYBkADsIIQ8qamaW0A/grgSgDLALwL4GQA7xmr/lHTtPv75mv0LhIrTFRC5RDs5wBFYswD0oFysFjpIX1OVea58NQPemZTM60mH9Nq4pOQ3+5qt1n64Ees6cfokixbMmUFj8jh/u8l36XufHsD1td34s1FszCpsvtS/t6Ag2fx27Oiye3o0Gv9WvxwQwMe+ngL5o0pxpOLt8MbimD1r0+07DkDgNpmH5Ztb8Uxo+OrHmIXXQSBqOV3V23aCSGYMTQfb66ux7LtrZZSzNevnQVvKGL7PQ5F0DlXX2xpRrMvjLljirGnXa+MiyyD48eVIN8tmPc4b0LCeV9nqMeJ/d7EQVPBGnLunfi85FKo5z2T9B4hBEHowXjQnzztnJbPY40CIoJ+E4sE2hHy6fa2QZLCbhrAsEIPCj0CdrcGsXJnG7746yKMemYivvpEz8rLHXo/l+y0lpZZQSQRFKMNjnB8Nqa+XQ9iKyyyPPsLvDEDiUdqy+/qzU9jsXgdTuh8rUefRwmWLMUQLE3DnPbXcRrzFfJd9gROZnTSIMcM+6U9M8RGTpcKSv5wPKOcjJXC4dDCfhCocAk2unej509QrbOtgjFUl7MZWm2F3EgjLuE+whjf0vhtGTI8zsZJUjUIlmpBsJ5/8Vl8+4f5WLfVfjA2ED2GEpv6+m8tPgK3yFfgmyzdVt8M7NI8QI4rl7CQ+6/+D77vrufugvEUYrE6EVtJje0yRyorcRK7HC6x5/p6QgiGX/4kIpe+iaLc/pc9DCCcCeBZ4+9nAZxlscxJAD7QNK3VIFUfADiZEFIGIFvTtKWanhJ/zmb9Aw6JFSw6nJUmpqwgU6OKDCpY9547CZt+ezLOnKJL8TtDMrYZWfpQpHecChNBMpTUH4yI7WdLNDNat6cD1/9zldl/kikG0qDhRESU+GuxLSBhTV0HdrcGY1wECX44uwaA7vIH6G6L5/71S2xu0K9Fd8LzuatERtM0M7HNduP6o/M/v96eXIUhhGBCRQ6OGp55sv1QAJ1zRYcGe0QWy2pbcPvr63DTa2vwxOe6CQ8l375QPMFq6Axj5a42PLNkO77d3f9JmYH36+omPJ5sHP3jR1Azylonewv7c5wfvh0BC5KUFdiFCaQWHjVa7VAMgqUG2hEySFkoTQZf4BhcNV7DI/xD4F44G8e3vgSOqPjbBuMw+3SSlMqcIREF7WvwteNaXNt0l/la0NeBR9S7cDf/FHJTkIzehiDqpIW3cPaLBetvQCVphofr2cP2BvfvMDP0EAKOkuiLoQ7cID2Be/i/p6xgRVj9XFkRLKYbBItmVsKygsVYiO2OS+Birb8frdg4NWuCxRtzxARX5gSLN5blE2aQcYZMjbfp51IM63Q1wSiksc2Ly7Zej5PY5Qh986zVqiZoFZAeU9vlCkbjn8o8fMePBQD8RHkOP+dehpNNrX0fPTRq1BKwSIAMNFBtv52mX1NVuKGfJ1ea6l2mmFSZm6RDHwRKNE2jMzH2ASixWKYCQKxzQ53xWoXxd+LrFIsIIWsIIU/ZSQ8BgBByFSFkOSFkeVNTk91ifYpEl78HjArGPe9usl1HThhKnApUikWJ3Iodbbj+n7pypDMoo7EzZM746S0MgH71fsOPjx1u2tV/vrkJv3h1NT7aqBtp7WkP4o1v61O6K363z4vVu9vjKo4DadBwIlYa1craJkNKbzEHi2UIxpfnYMOdJ+G3Z+rVrw17O7FiZxs6DDmfS2AxpjRaOeqqRPCDDQ245d9r9X3oxgVIHR+/sSBYg7AGvR7peXYLXNwIGpoQoOQ7cfREQ0cIn2xqxB1vbcBn3/X//Xjg/br2EzY4pmCZNhYBJTmLcWLD3/G2eBuqWpeYr2kOIzAKdUDy6xUsiUmdwQeA+VOH4lRmGSbL+gPnNWU2Pt6tYUN9Jz50nojLpRvRPvS0jPebWlxzWjRAbmvYjWPYNTiGW9unmT1awRLTSATZsH6DJM7Me82s0MaXoR6FkNToZSp5dQORNmSllCAqhqOdEooO+6WmBNSwoitwKR04h/kckzs/gUAUSBoLXrCW1jkNMuSENcF6WPwRrpR+BrZweMafL7r06zFRdigYzph2RhIarWAp8efs63eeNP/eLKZu3lUMkhpJU8GKdXVSFRVXMG9hEfcGRCF1EoCNmRVVmTfwXfKcUgtu4V7Cmf5XLd8PBPzgiApJ48DZXCODyAyEkA8JIess/jszdjmjCtVbdl9/BTAcwBQAewE8YLegpmlPaJo2TdO0aUVFA4MAR+dU6UG0aXOc4lHBswTV+a60cmErxCYamn0SZtz9EX7+6uoubycVqHvY/EllvbrdAwEjS7IwpUqX8W1t8uHVFXVYt0dPRFGHu1SVx/P++iXO/MsScyAxMLAGDSdi0dwRGFbkxqnGuaZEXo2dg2W85hI4MwZyGhLA9qD+nBd5Fu9eN8fcblcJVqyhSndcMYcVeuDgGezrDJltExStfgm//M9a/PGDzV3e7sGM48eVYOGsGjOh4ha5OGkz7REVOdayuNDQGYqRO/d/Vuag6cFKB8qCAxYW47RZPdbAYsvIK3Hp5tk4t2Ak5mQX4sLQkzi+Og9/TvM5FTUjsd4xBePDqxDRGKwZfjWwCXh+6Q5sC+VjmXo4flg+Ls1WouAMUsOp0R+ot1lPvHay+ei7KViAQAkWkaGpKojNpGxO0m/+rLtnTYZWMzy8rftQAMBLslNmlehMJjUcQ7B6UMHyhPbhQeEx7PXrzcVB4oCd0teVpRMsF8LQVAWEiSf1y9URXFbbPgAAIABJREFUqFMrcHtW5gTUYbhXOrR4gvUocyGYUBsW5VgPLVZpBStGIugPyRi59SkAwE3ylRCYESk/mx5DlU9NsHIiLbiY/RAlHeUIh8bACei9j0x6aUbw8s/Q8dVzGH7qdWmX7W84FC+u5t7CrnC55fsBXzvcAPzEZXuNDCIzaJp2vN17hJAGQkiZpml7Dcmf1QDCPQCOjfl3JYBPjdcrE17fY3ymOWeDEPI3AAPfeSUGQwpcmFCRDY8hT6VVqUgKF7WZwwvx+U1zM9r+k4u34921e/HDWUMxf1KZ5ZytnszBsgLtn2EOUalgyJCq5Tp57ET0mUiNRlL1zok8A2/Y6OM2QpyBNGg4ET8/aTR+flLUwIqeckWNEiyrniiaHGjo1JOOAkugaBrOmlKOiKp1ORnNxsQ33algMQzB0EIPNu7tRG2TD1Oro/FQR1DGi8t2oabAhRtOGDQuorj4iCEAgA83NmB3axAekYsbd0PvKxMrc/Dtr0/E++v24ernVwDQK5ayoiaR8P7EIUOwTlc+xPe4zVCbS4Hyw+PeY5VkowBXVg6CcKAzpMAvqfDDCbgyC4i5GZcDXyzChopz8f1ZwzF92w0QVyv4ULgFAFCcYvhcImjVSNCifUiBVl0VExD71tKa4zi0aFlQQZAbkWwrOKKsV/wET8/0xZcEX8S1/CawTblA9SwAgK+9EQUA/Fxq6dXH1T/BVXvPwKKiw3CE8RpjEumuEyz6XfO1DoAAIThgtwc8x+G/6gxIGoMTwmE4nPHExB9ObZJhBYdh950oO3xbORKdSgQ/91g3Ku8Vh8Hb2QGGi76/6vM3MBs70aDl4nVlNuZ5U/fUfZc/D3eGHTi5YhRmpFguJ1yP3/FP4bvOsQgHL9MJFhGQydF2Vk2Bs2pKBkv2PzgjEWNn9hI0ezad6H8fo4MabwL4PoB7jf+/YbHMfwHcHSPzOxHArZqmtRJCOgkhR0I3ubgMwMMAQEmbsfzZANbtx+/Q6/jV/PgE3k9eWgkAUDU9SO1qw34idrcGsGJnG+ZP1CsMtBpy1pRyzBlZhBtfXd3rBMuU5e6nHq+BjA83NOBDQxJIZyZRwkUNIVLN/InOwooeO9p3LrID32CBkmpK5FmGWJKlxOorzzLgWQYPLpiC7vDy2AD9mFHdq04PK3Jj075O1LeHMDVmZGlvDOQ+mBE7381q0DBFVb4TP5hZgxHFHlx8RDUIIbjzrQ0Aum5Msj9wyBCs2fISTOGWY33ruQASCJYReNNqERC1tu0MyTEBcWaHa/RxlyI87nBMKhkNhDpQzX4Doqn4XehurGaHoUi0nyGVCEeWHhe4tWglRu7Qn/2So+8lKXO0vyMgKVincbATfjkiegXLmdMzAjgmsgET2VVY648Obg516LraMJ/a+Yi48tGKNvgj0R8ka1QB2VRW+zYoqBxhOlEChkthCtzC/QJtARkrFBZxn6aq+LH8HLysCLdwUsaf78rSv68rgWCFLAxaYvFx2RX4V30d7suNWjQzTfoNaL14GGbIm1DeugeJv4lYtGpurNdqMC8r9VBrKlPk1RBCQV1WGD4IazjpehHDBsFK17M5iB7jXgCvEEIuB7ATwAIAIIRMA3C1pmlXGETqtwC+Mda5U9M02hRxDYBnADihuwdSB8H7CCFToEsOdwD4UR98l/2G5TvazL9lRQWbQUU5FbgEE43YYFFWMjfL6Apoj9iWxmTL64Mdy7br/VXnHlaJEcUefLGl2TQTkTOYDxZVgkQrjQNZIpiIKMFKXZkojRlCffrkcpTmOHDE3R+ioTOMr391HIqzuvbcp587Y2g+ThpvrRBJh9+cMR4PfG9y0vNZigwSLCvsbg1gb0cI5bkODClwIcvBoSMYPXaJx2t8eQ7GnxGf6qbS6MEKVh+CNuhHYiRjFJzRxxLbL1ES3Ix/Cr9FZ8MQENfReIl/Hm0dZwDIbNicWGZkEV35CE28GJ61z+EEdgVOYFdAcz+c8X5n5+okyqP5TVme6tUJh+bO3CyjtyBwDAKSot8gbEoTbsMsxJXdM4KlMnpwrkhR9yu5UydYspi6NkAd/vwxktDf5d6Jb3c24pmKzAkuhScrB6udUzA5pMdp6QiWS+DQFpARkBTE1vGkkA9XsW8hwIgQ+b9n/Pmiw42NajUCEDFRjkDgOaiKigu09xBmBYjsKZbrUWlsKKYZNBhhUa/lI1dQ8LxwD2o7hgC41vazg8YxtHNNpIgSrDCkEJ2d1fVq4UAHn4Zg+VQB7yvTobgq0XdjwA89aJrWAuA4i9eXA7gi5t9PAXjKZrmkqc2apl3au3va96CzggghcY3gsqJaJmNeW1GHO95aj3MPq8QdZ1jP96Ng2XgTDckIfBlC0G70mvR24Dh/Yhk6AhJmjRj4g8h7G1SqNrzYjQKP/kyk7naRDAZEUxIVO+rli5vnQlY0OLphXd7XqM534YLpVRhTmoWTUxCdkmz9WXPapDI8bMyvokmA3a2BLhOsxHEH3UGhjRHXQJZo9iee+LwW/1i6E785Yzy+P7MGQHzymFay97QHseCxr1CcLeI/18yK24ZphDIAyOshQ7BoT45iRbCoE1uMUYCbA8YxG7FZktDoG4Kj2A34OnJE0rqZwHPaPQhvfB2iUdkhXbCidjgc8Gsi3CSMoL8Dzqw8MH691YDJtjLN2r+w6otKxHPafHgirViQ37P9owRLlaPySMlwtNPSGGiMal+CZ/gnEdgzF8BvAAAhVa+oCEL3qirS8JOB9TrBSjcTqpz3gycN8Pu8QH5UIhj0tUMAECAOuLqgWyAMgwvYB9ARlLFKUiHwQDgcxJ38s5A0DoSxHtnj5lTkwotIIOrOtzj/LFy+cQpunpaLw1Z8hhy1zXJditF738A93FLkBS6D3vtvDcGpW4iLWgidIb1X7KAmWFrE8v0WRzWulm/A3KIizO/LHRvEIADc+u81eOnr3bjnnIm4cEZ1XHKFVgESEZAVeEMRW2fMWLAJJhrU4v3l5VGzxt4mWCxDcOlRNb26zQMFZsVQ0cxgk1awCj0iDh+Sh5oC+/5YkU+WCHaVbPQnJlbm4N5K+yHZFKNKsnDO1Iq4GWrNPj22W/D4Umy7u2vzwk2XzJ1tqG3yYVhR743IkAewi2N/gt43Yvs6y3KceO3HM+ENyRhXFnVe3tMexJ72IL7Z0YriLBGXPvk1VE3D3NHF4FmSUjbbVzhkzq6SgmDxhkNfbAXLla3XHVyqDyRsyBLEbv7ARA+4i/8JAGgrStXFYo1fcTfiQulX6JD1G+VWMgSfKpPBFvV9c+SjkTvwlbgIaov13A1V1fCX8Mm4N3IRsrMytyG33BabTLA+KlmI4aF/YOPQ76dcN1dpxrHsahT4tpqv0bJ8V92EKIbPPtf8+7Pcc1Iu+5vQPfhUvBFk78q414M+w/IfXZePeQyJqs+QrIYDxuwZYk8Yj2l4Ft86foSxO/9hvkZnR+QVlUHVCPI0L0Jh+xk5lZ2rcCH3CfLDe1Lun4MSLIQhRVTUqqVo5vo+CbC/IRjOnoJNBYu6dWUqKR7EIHoThEQz77KimqTqH5fPMO8hiaCVkEwCvkQb+NMnl+P1a+OzyIOZ+d4DDfQf+GAzGAJMqsxBtZG0O2ViGV778UxcdbR94stKIngwYnx5Dh48fwpmDi9AbZMvjlB2J9Qeku8yieurK+rSLG2NiKLior8txZz7Po6rhJm9c1z/k4CBBHrfaPSGzXiNZQgOH5KHY0cXo9jos4slT9977Cu8tqIOu1oDqGsL4jdnjMeW352KC2akbmnoCxwyEYBm2HZrFgTrRvZmhP2d+Ft+jfmaO0fPgng0PxhZD2QZMXkad6Zgh84CfroOeY6uk4517iOx1e9Dh0RQCuAFMh/r5Tl4fdistOv2NgrQjjLSih2h5OMIAN5QBJoGZIlcStlCJlAYvfqhytHgv9UvQQGLnOzU54Ix5kIxMbbmN3nvQbbQCHfgGcDWosIe+WVDsYUfjdYwQZNndMplJdYFyIAUiO8ZCAcym6lmBbfIQoAMfygMwIUQleGl6nOizn9y9DhQgpblcqKDZCEPnWhv3ofSiiGWm+Ai+rqcI3WCweHS33doEtqyRuFi6UEcVVmAlzL5cgcQOF7ATq0YEY3FkEgEHBd/G5V8rahAE/K5wSGSg+h7xPZI0eqVR+RSzlEze3kyyPpSyZpqBIxFWSKKskRU5TuxuzWI2+aPHZzZ1ouIPSfTa/Jx2iRr91I7/O6sCQhHVAwt1J+J3pCMn7y0CvkuAQ+eP/CNhTpDMna1BECIXk3yiBzOOazSdvmr/rEcmxt8eP+nUYv27rhPFnhEnHNYJR78YHO3Bg0DunRzW5MPDZ1h7GkLotogbA6ewbiybAwpGPhjSfoS1Ib9ic9r8cmmRnzws2Msl0s0sHAa87KCsoJQREnbztBXGBh70QfQqCxPDiS9tzlSik6tMM7tzenRe3yy4IcW0Huindk99ATLrerWanTeU6cxvLHJqxOOrrgR9hZko1oSkaxnPHW2NeFk5msoYs/nlWhGBUuLRAlWi1HyL3CnlvmxBhngItH9HKHUoorZizp0P5O3bO6LuO3N7/CjoqEpl6MzoyLB+MG5lGCF08yUssKfAzdjrGMjNtb/Gyg/DlJQJ1jhFDI8OnqAkaPH4fI9t+FOcR32tD+KDiYXeWonvM31tgSLNUgqm4ZgiaITikaggiAQ0s/TgaDx7zIIwUnqQwjJKjaoyTfRyh3/xhLHg1jWvADAkf2xh4M4hMHGVJho/5WdCQ5FNKOe/vc6tkyXYo0pi08WOgy3ujkjizC6tPvJyEHEIzZRSY8xhRRRoWoaeJaxdU0bWZKFFTvbcMETS3H+9CqcOK4En37XhKJ+iB+6gxU72rDwmW8wuiQL3zV4UZbjsCVYO5r92NygJzVjq7HddfenVafu2LRTDCv0oKEzjG3NPpNgTavJx7vXz0mz5qGH2Mp3rAKk5pZ3AADvXDcb48tzkpL3Tp6BU9AJVlAaJFh9DtlRhO1qiW63ngDTsjTm5kU4AQE44CIhVIc2AgQoqknqh+4TzFO/wgncKqh7XFCqjkaefxsk5Ng2UO5PRBgBUICIFLJ8X9q7AY8Jf8JGZTSAq3v0WS2u4fiscRLCfLSx+cd1N+MaoQ2q9gwAexJHqy2cEiUW1Fab9tB0BxcdORxFOR4cOTR1dcIcdByOr2DJAb2HTM5gaHUiVKOiJ9FthHXiI6ciWMboARJDND1yG4pIJ1ocIvx8PhDeBX9rve02BOMY8s40VUOWwVj1BQRl4A8hPbCLtVg9mCCwDEKyCimiwpXA9TXjnGvCYJA5iL5HbI8UxzA497BKvLayDve8txGXzx5q2X9juv9lEEieOL4UJ8aYDby3di+WbGs2Hf5S9ecOouvIixmoKvKMKf108Cwe/ngLHv54K244fhSuP36k7Tb+t2Ef1u7pwNo9HWbC9kDp/6HkSMrAMfHK55abf8f2AXangtURlPHMlzsAoNsVLEC3av+qtgW1TX7MTS18OeQRe86s5My1TX6ML89Jcil18Kxp6HXza2uxuzWA208bh9kj+9cU58D4hfUCttZcgLnSH/F54flxr2uaht/ir7ib+ztEJr6y4Sd6+baSNEMFQdGwyX22v7GYHl6Gq7m3wDauQ1vzXvxXuAmfOm7sF527YlSwlLB1BSvs1S1lQ2nmVGWCNeUL8H35FmzJi5aJh8hbMIXZhrzs1KV1wSBYvBolgqLhFul0dr9ZlWEIThpfihyLKeKxUHn9M9RQPMEKyirqtEJ4ha7/8GVW/87UsMIkWIw9wSIGwWKVmOOg6pUv0Z2LkKgTxXDHPtttCKp+roUMjpuD149LQe0bWCf+EBc3/SntOgciRNOdMbkaSiSdAJMeSIoHMYjugjXdz4B8t4AHFkzGmNIsPP5ZLZptZt5FaAWrG0H38p1teH7pLvPff/jvd1i1K7VxziAyx/em6coXQoAdLX4M/+W7OPORJQBirMtTkI7/rKrD45/Vmv/e0qDfn7rbi9zXoOSI9uRwjP1+x1q1C5yeXACAUd2oqLb5JXQYrpipjm86UHOM2qZoLEBdPgcRj/gKVnJyNjpEOKGCJbBmMndroxffNXgRkKxNqPoSB8YvrBdAS4ZBKT67FpZkLOA+wwXsJ2DYeMa8RJyDt5Uj8boyE587jgMR+kcvq4i6FEMJtKG9UW+27GD6Z4SpQq3TZesKVtinEyxJ6JnBBRD9sdEbK1QV2Zr+cMhJ41AoGNUWSg5URYUbOiGh/XX7E6pAe/68ca/vzJ+F2eGH8O/KW7q8zQhvEKyQQbCkMCIag0gKgsWavWjR8+VU9ePgzMrDF8N+himhx7Ey50TbbQgGSRVd6R9SNIskBzvhISHwzMH5IHlOuQWbxO8j3LA56T1G1gkscQwSrEH0PaI9WFHyz5nW6tby6DkjC3HzyWMwc0T6vsH2gITNDV40dOr3BTnBefCLLc1Ytau9W/s+iGTQPjqRY0yVDXURjGQwd+yfX++O+3dbQCcNB4oRiUmwYgYN26E0ZtiwwDI4epSeyKzK63rPc+zndKcCRjHEMCSpa4smpV9ZvhvDbn0Ht/57Tbe3ezDizCkV+NHR+nATK5MoSrB4luCaY6PGLiIXrWB5DROvnpDi3sIhIxF0Gew2kEiwQgE4AITBw5nwI/pX4TVY3N4MALhkTDWO7YsdtYDm0IfMasE2+Ft0Jzcf3z8N9OZsKtnadU4xeo4UvufBpZOJIB+dQNggFIF28FDh1ZzI9aSpYGUX4gPlMLSx5RgGwB/0I4sokDQOgrD/LWqJYFR7pHgzEJpVcXVDOqcZhhVqSCdtTXlTcXr4ecwdko+nbdbhHPo6sVJJt+YHiE6wHHkM2tGBFr+1Ix4AbEEV2lUBpZ70pP5u5QFUCDvQ0jld32fu4By2KxAFDiIj7O9Ieo+a4qTrWRvEIPYHThhXiopcFyZV5sAbklHfHkKb8ftOJEMURwwrwBHDMnumvLm6Hr9+Yz0uPXIIfnvWBHObp0woxRdbmuELRzLq5RpEZgjF9NHRnlZzDpZNRj8WtGeboi2gVzEPGIJl7GYmRiyxFSyeYzB7RCFevupI5CbquDNAbIDeEzVlriu+hx7QZ8epWtTxcxA68t0CyoxzGCsRvOTIavx3fQNOGK8n1gkhuOnkMVi7pwNfbGmGU2CxYFol5o4uwjtr96LFL5lmPP2JQ4ZgVbR8hbXiImzbPQXA++brkjmvR0jqzsp2Rg/PmNKeV2S6C+LUCRYT7kCofS8AICT2j7Z0dfYxWNxZhAkuawtMVdKPJyUDPcHUfa9ipeNBLN11AYBp6GxpQAGADpKFrDS9AkJ+Ja6Uf448nscCAIHONmQB8BEX9n/9CqgrPwUXb87G9LzDETs9zReOunp1FVR2SHt8qDxN5O0fHkrReFwjXYfcvCGYCEBVFLihZ549Wbko9Oh/N/vsbdp/ovwMfknB2rz0xiUVWgNGMnvgCxkmINyBM2+lKwizbkCBJcHiqeuis//uGYM4dDGlKhdTqvRnxkcbG3D5s9G+FLs5WF0Bm2DTTnuYjxtbgiwHh1eW15luYIPoOf6zSk+qtgfkpAqWnEEF666zJuD/3lyPqnwXPt7UGCVYB0gPFq0e0dlRqSoTJTEVLJ4lWLPbi9pmf7cGVMdWsM6f3n3L78o8Fy6fPTRuVtngHCx7UJfj2ArWXWdNxJ1nTEgyG7nvvEloD8iozHPimFG6c+k3O9qwrcmfkSPq/sYhc3ZFQUAWCUKMxFcUZKOXSEZyT00568XV7JuYx6zE2KL+c9xhXHrlgA13QOloAABEXP1jg7sm/yQ8EFmAZqfN3A2DYKELw5TtQDj9mBND3tbZqn93H5u+vyuxYumVgRcj8/Apf3SP9ysTqLlDsESdiHpSHPf6lC0PY6V4FY5seb3rGxUpwdKv4Whm0/5nzGWX4l31SHwLvbs24O8AQzT4NQdYjkO1XItn+N9jft2DlutrmoaA8TmZOPPIjP6AEyVdInSwVrBkwwVSTnCJBADeuMfwrkGCNYj+RVCOV2zYVbBW7WrD22vqsbs12WU3EUmDhpWobMfsCRoA2eODBbT6cs7UCvNeT+/9EbMHy/54zxxRiA9+dgyOGKqnFhlCcPzYYhxe0z9tBl2FSbBUDSxDUlYmqERQ5BgILIOXl+/Gba+vw+rdXZes0ms4z8WbxiDdQWmOA7efNi5uUDb9HR4oVcS+wtq6DnywoQGTq3Jx2qT4hG4iuVqytRkb6jsxotiDLEf0/ET7tPqfYB0yFSzeqUvKODW+d0iis4QsnNhOaX0Oh/OvAQB8zvMAlCYt0xfg3fqNkZc7Ifl1kgFP/wxwpY2xks2D2rTB7xWCpd8siaJn3ALtjQCAIJebdl0Hx6IErXApYSiKig5k4ZeRKzA5NxepRwT3DlxG9sWfIEnlpHbkEx+6Y67XUHIsbtqioMYzE7MAFO56D+8JD2FX20kAplquQxs/6QPZJwF/ki9GtsjgOgD5DmAGuxrbgl7L9UOSAlELQ+McKbXvFBHWAciAS9ErO6QXroOBiAjvAYJRSWws/uq4HH7/HtxU0j+uo4M4tLFpXydW7mzH6FJPUs9xxKaC9fzSXXhtZR3+cN4kVOWnVh8kVrBoNn7lzjaz2jIoEew98Gz0eNMKVjiiQtO0mApW+uNNKwKVeS7cc87E/bS3vY9x5dl449pZ8Dg4DC/ypDSIoBLBoYVuEELw1Ta9J/yDjQ04a2pFlz438TrvTdC+8lSVx0MR+zpDWF3XgePGFGN8eepE+jUvrERHUMaq209AnlvA1kYvdrUGsKNFj+kP+B4sQsj3ANwBYCyAGZqmLU+9Rv+BTzA9oJDDRqMuSZZZxVlGlo7aj3uXGkJ2Meq0QrRpHrgCOsngc/qH7JVH9uBYZhWEDg+A5LlJH5RegWu2z8ZPqiegp2OQGV4nvYyqE6xGpgDLIifDWTTWhk7ErMsQfCH+FAKJwBc8H15D/5zt6JucQqG8BzdzL8HTVA3gsOh+GT1Z3enPCRdNwCuKinM4/UHBduzGWGYXfMSaHAGASwvhavZNuIIigGPhU3n8XZmPYW43rgOQVagPrcxWrF2/Ah2N2ORYiDZkA9htuUwsZGOAcpZqEA+h51LRgQiF0xM2SiiZYK1RarBLLcavcwaHrQ6i77F4SzPueke3ZB8SI0uqynfaBuJdCdRp4EIHDVfkOTGmNAtLa1vNZQYlgr0HyidCsgKWIWalUFJUXHRENWaOKMS0IemrURW5TkyvyUN1GgI90OAROUyuiiZVU/UtjSj24N3r5phEq9HoP/t6e6vtOnagFRBvKILFW5p7ZPm9YmcrWv0yjh1dBJ5luvR7O5QgpEvgx4Cen5++/C3+eP4UPLVkB15ctgs1BS5cdtQQy3EUfY2eRpvrAJwD4PFe2Jf9CuqAJmjxFaywRrBSHQGfWJFEF/IijdF/MP03z4etno7Z4YcwKteDErQA0hG4eeS8ftmXaW1v4yfC81i6LwQgecq2T+HQjBzwrvRVpnSgFSzGqGDt4IbhzshluNRmIG4iAsQBAT4E/Z0Id7ZjAqlFBds35zE70oYfc2/hO9/YuNcFWQ/IqeyzK6B9W35Do4yAbsCiue0DeSeRcQv/T7QrHgAPmQ47Wca2cg2Clad1QFUUMAnHJ2zM3AojM4lsSCwAAsB6tRqLlQmYXpiOCh+YUA0Ldmo4EgtK5rvTZzeIQfQUURdBzaxgXTlnKH41f5ztOl0J+KhEi2b2bz9N3+49727Ed4YFuHOADPo8GLDSsLz/3wZdvfK7syeCYwgYQjCtJh/TajLrKp47phhzxxQjIEWwryMEt8jGSasOBjh4FuPKk6XZ3VGLuUUO3zu8Eq+uqMOe9vTS2f9v787j46rLxY9/vrPPJJk0S5Ou6d7SlRbaUrayI5uAoggKghviFRfkoiguKNcrLlcuyr0iV1DEn4igCAiKyCJrWUrLUpbu+5ql2Waf+f7+OGcmk2TSzCSTOTOZ5/168WoynUkfTpI55znP9/s8h/LZu1fT3BXh5etPoaHKQ8SsJMsSwd6SFb1nNzSzvSWQGsycSfJGz7/WHyCWSKS6CH70qCauWDnAFpYCG9a7oNb6HSiNTihun1Ex8Ojem/nbfdP4WOR7HD2pjr67c7yzVsKBf9FRfRhW7qZIrv9tD0bZHa6gK7GIn02eZk0wdvOuQCxzU4Tknieva/hvHHaz21+ygtXSZfxZW5FdR6Cw8oDuIhzopHrn0/zV/U1eazsNOGPYsQ3GbTY46FsxdUeNpXPuqtzvhtXEm7nE/jiNbROApTiCRoJlr2oY8DWeCuPn3q2NYxdp3c65theots0CjsPt8dGBD78K0Nqyj9qGCb1eHzJnboVsWd4NmngktP2Fbu3h9vj7WTR2dC6T21W/khu3K6b4juCYtMdDoSDXRG5jj2MstRVnWRafKF89S5sSqT1YyYuPgWQzTykpPYFLl1w+/uVTZ6U2nIvhS2/cAHChORdrqB59cy//ft/rfHDJRH76kcXD+lqFsLMtwP8+vYldbUH2dYRYPq2W752X3XnlyhNmcNu/NnHVyQMPYT6UuFk+HE6bdgC/x0lzV4SOYIyGKnjf/EYmjvGweHJp7IMrlPTZbNtauw+dYKXtxfM47al998HI4NWvQinYbSal1BXAFQBNTUPvyDJUbm/yQrN3YpCcOu/O0Cig/uQvwLgm/DOsqRYlJROs/Z0htIYqtzPV+rPg7GZyE8s8B+uMvb/kPOc7eLq+CUwa3j9lLhG0J4zvmbN5HUeqrUxwZ3eCMRIsowqTah/vKsxsIneF8e94Er3vfPniRhy+6iEkWOHd/Ifz17zTMRf4Ku6IsezBVT3wfjy32abdqyIk4nFce1bzM9etrO5eCVwOQKutHn9iO617t/ZLsJIVrIgtu71UY+efwO/XnsxzCeME6HFy8TNzAAAgAElEQVRYV/kdSe2NR3FHvIrLnL2rqc17tnOJ4wn2U5fVnjUh8i1ZYYondE+CNUhFKbXpPosK1orpddx35dGpG11aa5RSqeHbya6CIj8+eew09rQHOffw/nuI/v7WHnYfDHH6/EYm1Rx66Z/WmnAsQYvZMbZUqicHA1F+/1LPIOsJY7Lf1/u1M+ZwyYqmQY/NQJLLYIf7Xl6VdpMcYElTDUuaJLnqK72CnmkOVu/n9nxPvE47HvP95+WtLazeVs/8Cf7UY1YZNMFSSv2TzN0drtdaP5jtP6S1vh24HWDp0qUFnz7qq6jipuhFBJWXG8wTAkA4HMFJDE+mE4vDDYsuLHCk/flcdl5wf4EJqoVH4svZXLEcpd5nTTBOs/HEABWsKcG3mWd/ndd1MOPf5yJcP58rI1+mvraJhcDK3b/iS+7nWd1dAywa9PURmwcSEAl2oc29MrpACZan0qhgefosSa009yZV1AxcdRqIu8LY9Ok2kzZf1Fg64hsz8H48ZbMT1C68KkIo1E0saFTQYs6ePWAdrkYIbadj31boVY+BmNn8IpplgjV99kLOt32WpYnXeL/tBfyJGYA1DVlGUqW5ly/Zdj/p4L6tTAIOOuvJ/TssxPAlK0yxuObjR0/l1LmN3PncFhbd8BjfOmceH85QAUkOIM6mglVb4aK2omdZ2rm3Ps/bezpSXb+SM5pEfnhddv7j/J6mFA+/vpv9nWHOXzyB363aznMbm5nZUDloErFhfxen3/xM6vNSSbD6Fo9ySXaUUkNOrgD+snZ3xhhylbxJnj4LS/SX/jM52BL79CTCabelKljPb2zh+Y0v8NS/n8i0+kPPSx1pgyZYWutTCxHISHM6HNzBeURjmm/EE6luPHU7HmOD5xrWHDgRyDpfLCilFC5lXMidbX+ZNRk6HhYsFodx11KZy/b6cpot1R2e4f9g26sa+HtiOYfbjf1c3oiRULizbPCRTApiwa7UsGLlKUyC5as0Y+6TaN6S+DD+eDtX1OS+hMZdYSZt5rJDf9xoPVtVd+jjEVJuvEQIdXehzUpeIi3R3FF7NO9t9+KJVqa14zBEQ8bMrZg9uwTLYbdx+KQxfGHnAyyzrefdwErgsKxeW0rqEi2cZ3uOyW1TgMNTjwebjUYg3e7Rl1SK0mBPW8I3cYyXiWO8PLh2Fx2hWL+27UnRWLLVeu4X3dF4gnhCp+443/n8Fj505KSMe2HE8P3i6U28vaeD5VNre4bvZpEY9x1uXyozmPouz7Oi/fYhGhdmJdlcq8OsYL2wsZkdbQFWTK9jSp21SUAxSU+qBqtg9e2I2ncZdDG0aS+N37A8SX4D0lvXJiLGxWrCbl3Sko1u1VNxCPsLv8QyKdl2e6AKltNMKJxD6JLXV6qjjLnkpCJmJBSVtdldvCaTgmioC1vESBSUuzAnfa+3grhWeFSURMx4Uw1F4/w6ciq/4MP4vLl3uPFVGhUsL0G01twbO4F7YidRPXbCIV+XbFARDnahw0ZFKr2St232ZVwbu5LXEzP7vTaRTLAc2d8FPH6CZpltPQCOUdpFcGxgI7e4/peTW//Y6/Fo207jzwprunwKkUqw0q4Kk4nTQIOG7/rkctZ++zSOzKIb3eYDXdzw0Dp+8/wWoKfjV/qsIE3BF6mUjfROa8lGI1m1ae+zTLRUKlh9Eywrll4PO8FKVbCMJlN/eGUHX/vTm6wdwnyu0WxSjS/VgKtykGXNv7z0SIDUdhlvnxsIo6FN+weAnwNjgUeUUmu11hatXRvcqY612O3NBDuXMsZnXKQnEyxd5AlW0F4FZvM4VTvdsjiSw39tA1SwXOZ+KZd3+HdlvLF2Pm//C55uP3A81dpY3uavze7i9W8Nn+QHG07lkqqF1EXvB8DhG3xIcT7Y7TY2MBGd0EwMdFHhr6EtYByzap9zSI1hfFVGVcyng3QEY9wcu4BKt4OLvYeuyrXbqrHFY4QjYZRZySMt0ZxormnfdbD/ss6dlQv4feRK5o6dy5FZxnmcZ1PqY5d3+Il2MXKZXTJd8d6Dy1WHMQdI+3ObuSJEvpx7+ATOWzwBpRS/fXErW5q72dZiLCseaNCw12Xvd4EykL3tIX7zwlZWTK/l8mOnpb7mxcua+Me6vWw60F0y1ZFSlH7jMZasYGWRdPjcvb+/pdIivO//mhVxZ9tYayB+s1tjsoKVvGksvye9aa3pjhgXuhXuQ78fNfjdrJhemzq2p85t5IXrTuaknzxNOJYoij3Qw+0i+ADwQJ5iGXFfjP+Wqc6dbG+7CBqNBEubg3ETzuK+0x5y9CRYvnFD64iTDy2TTuWYF3/G0dOnZrzgTjYRSbbFHw6/2861zj9yMFJJNPJ9/HQT14rquuwqWC1V83kh4ecc5WdczKjEFCrBArjYeQvNXWFewksF0HVgJx+0PYN2TQVyX3nrdPuIaRtuFWNzq5Fs1lUO/sZ/Tc0tvLWrg4e9TdgiRgVLeXsSrEnVDmaoXVQe2AN9vqsH7OP5c2Iln6rNvmtl08KV8JzxscszOgcNJ5druvs0MXEF9hp/1kiCJaxhS7uweGzdXp7f2JKaIxTLYr7MYJIXLua2rZ6hqQ6VU0VFDI07rYKVrEhmc7zdDntqhhaUTgWr783IQl44V3udtAejLJ48vLEznzl+Gh8/ekoqUZM5WJmFYwnqKt3E4gkcgxybhioPf7ji6NTnFW4HFW4HPpedcCzRq8ugVcpqWEXE5oU4RENpd50j5gWSo7gvBKNOP5j9EmonWbenxe6pYjf1tOvMCanHDNKTh8pFbf04otrOGNXFnt1bGA8cVH7qspxllbwjG4jE+F/vZznQfhbfm7xi2HFlq7bCSXNXmNbuCI1+D9Hda/mp6zbWxo4EPpf7F1SKbuXDrmPs376e42xv4ncPXs1MLo0NRGK4o2aimZZgNdnbecJ9LXvb64BP93ptsu1+3/X7hzKmsWcJa0396NyL5DWrid4+CdbeuJ8tiUZ8Yy0aoyBEmuRy+OQekMgASwSvvnctBzrD/OhDiwbt0pZcepNsjJF+kR9NJVvWX9yMVsmqRzSWyKk5CYDP5aA9GOXHH1qU1XLQYuBx2pg/wc++jjBnLGhkSQFbmzsyLLcdirrK3iukkstq5fekN4/TzivXZ3fz+ebH17NudwdXnzaL+RN6bpwn92aVfAWr1ERtbogbXeVSYuayKGdxJ1g2Z88vaMMk65YIDtaK98nEEXh1kOMqhp9g2ex29qsaxtHM/g2rGQ902MZQl+Xr5wVXc53jMer3ncHm2GQ2azc+/9CnsefKuFulae0Mwng/kY4WACLOoVfRLqn9A2/u7uAnW97gd64fsDZ0NHDoTpfJVqXBaJz/q7uel5sv4ZYpPXd+asdPJaEVY2klFArh8fTsD6tvfonL7S8xOXIWMCfrOPXVbxMNduCuKI2TeK58FT3LNdPdEP8EByIf5cXZx1oRlhC8srWV7z68jiObalI3SJLLaAaqYL26rZUdrcEBlxCmS28DD6SSqvV7O9ndbtxgcxbB/ofRKn0PltNuw2W3ZX23vsJlpz0Y5egZdcPqrldIk2p8PPLF4y35t7vCxrKh0ADNYYaqp4IlvydD9fKWVl7c3MLFyyczf0I1O9sCfO/ht+k0v2fFcGzLKsGK2b0QhajZehpARY0LJFXkm/F3163gyNZHaKGGOqd109f9XVu4zXkzkdYm4KhefxdPaL4QuQqlYLNreGuWk9oddYyLNbOxw8GVoZ9z1GQv/53la6cG3uJCx195oW0snSGjhXAhJ9dfGfgld7kfZt2734PZnyfWbSRYUdfQlxvMbKzizd0d7NtjdKuLuGsHeQV8+uDP+LH7eXZuv4mO8BQ6qMTn69kjZ3e6OGCrYaxuZdeurTTN6KmQzmh+go85/8xLXeOBM7OOU1VPxFU9epfJ+aqMJLmCADqRQNlsRGIJmrvC2BSMrSzuPZ1i9OoOx3hrVwc1PlfqwvDEOWOZN8HPEQPM3onlsNQs1QbeTLC+dc48QrF4r7vxziJYnjNaeZx2XA4b8YTOOfH49vvnk9CaGl9+zs+jXfJG8hs724eVkK7f18l//eM9ptRV8I2z5vYs05QlgkP20hbjeupTd73K1pvOJhJL8I+39wHw9y8fXxQzOMsvwQLi4Z4lgi9XncoDe2o4pbG47zjvmXw2U9+cwXEz6/mdhXF4dTdn2F9hQ7h/95vkydzrtA+piUMm3a6xEHuPtgO72cMcIoeY+dSPmTSraIBrwr8g6oBK+/FA7h38hsLpdONWMeKd+wHQ3cZg4IR36FWdmQ1GZTBycC84IO4dvCJXSYBxqo0doYN0ho2kp28L1DZHA2OjrbTt3dIrwbKZexRtLmklm87hchPSTjwqSiDYha/Cz/72Llw6Qo3fP+j6cSFGSrKakdA9g4aPm1XP+OqBV2nk0u472dUtWcG6cJkxV+udPR2p52TbMEPk7uaPLObmjywe0mvPWDCOv76xm9uf2cxZC8czZ1xhxpbkw76OELsPBmn0e3IaNjwcy6fV8vKW1mEnpIFInMfW7WPRJOPGXEz2YA1bos+qTZ/ZdbChys1h44pjRERZJVhxs9V0PG0P1gbHbB6JV7Gyrrhn9TTVGrFbPVvEbi6ldOj+A/MCwSBNah9uR/7etCO+sRCAYOsuYE5O3XycZne9RKiTD6qncDniaHfh7txpn7GYUXc3A6BCRoKlfINXnQay1PYeT7uuZqrNuFNDxeDztBLm/sJEOMi3279DzBmmmnuBnqWKAe94iL5LYP/WXq+1x4wEyz5Ip8Jy9D7HHezotrEq7sIHdG5+lfc8l/OmXgScYnV4okzZ0wYNJ/dg+ZyHPtXnckfd67Izs6GSybW97+gnmy9MrfOlliWL4vPom3t49M29zGqsLIkEa/fBIMfc9GTq8ytWTucbZ80tyL+dvIkw3Jbffedg/eXzxxJP6H4t6EXuku933rStEMWirBKshJlgJSI9CVYwrepSzE6bN457PrMidQfEKi63Uf1xZGjTHmvZwjPuq9muxwMfzsu/F6+cyO4DtZwSepyZztcJhT8KLBz0dQBVjUajgcrOzbhUnDBO3M7CVK8AbFUNANiDRinbHjKqfvZhJFjjx42nKZlcAQ5/DglWJMDhibfw2cO0eHvfAYxVToAOiLXt6PW4I24soXW4pYLVl/L4SXQH6ArHaAC6DmwHIOEana3pRWlIXgzGE5rpYyvpCEVp6Q7z3MZmJozxsCTDMsGeCtbgCda0+gr++ZUTUq+795UdeJ12VswwbigNtD9X5N95tz5HIBLn/s8d02sO2UCeenc/j75pdjotkeqJlYOG1+02uvVGhvkznZyD1W4mWEqpopjTNBokfx6SVfPOUIzr/vQGN12wyMqwgDIbNPzM1C8yJ/Qb1jR+KPXYwvanucT+ONXR/RZGNji7TXH0jLpBp1uPNIfLuDB30T/BCgeNxDWi8pfE7Jz/WY4J38raxHTOtL/CeJqzfm3D1HkAHJYw5jIFKGwjE1eVkfy4wkblyhk19v45q4beaGPCtPlEdM/NAHf14EsmtZlgqXAHPsIktKKyqneibhtjLPOxde7s9bgrblSwnFLB6if5u5jcCJ0cMhzxyZBhYZ3kBWksofnL54/lyWtOZM32g3z+969x96ptGV/Tswcrt4u+QCTON//yFjc8vC712j1mowsxMu54bgun/fRf3PPydjbu72LD/q5+s6IG8uDaXamPS6VNe9//t0ImWKGokVjtaus/IzIXqTlYoRh6uFOLRS/JZZbp7133r9450NMLqqwqWC5vBWFcdEd77kac3vUA853reC/0PrKtjJSz5FyjTEsEoyGjO2PUlr8Eq8FvfK06ZSQnDn9D1q/1j5tJFDtuZcQatFVQyJ523jFGi3JvxEiwbqj6Lu+27ebOKUPf7+dwudlin8S0xDbz38jiYt5c1mkPGslpF178fZYMRQ87n/etGcN41yzSo3MmzK5gkmD187nwHUx2vQ67fgKTToGO3QDoqgkWRybKWfICNJF2IZe8Wx4doE37mQvHEYklcm5OkT4w1V0Em8rLQVt3hA37uzjQGSaa49wxX9oN2lKpYPWfg1X4uCfVDO/mrMthw+u0E4zGCUTiXPm71XSEYtxx2VLqpSHSkNRVuGjpjqS2z6T/nMT6btCySFklWMlZPgHzjjOAM2EMxnV6ZFlPNpyHqGBFzQpWPhOsxirja9Uro1Tvqc4+wcLuYLNzNtMi63GpOCFbYTtFVtQayU9l3Ii9LRilCx9j/MNLVlp805nWtY3bYu/nvImD7x1U5hBtZ/AAAN3KR9+dfOMnTuE93URLizFNPflmFdcQ1fa8DI4ebSYl9nC4bTNrO4wlm44uI8FyypBhYaG6ShcXLZvMxDFeEgmNzaZSF+DRAZY63XLRkqy//t72ECf8+CnqK93cd6Ux7sFpt1HtdXLTBxdavspitEu1aY8lUs0Ssq3qVKQ1HynZClYBl9Y9fNVxvLHrIEfPyHY4zMD8XgfBaJyOUJR1uzto7e5/DSWy97EVU/jZExs4bV7PrM3jZtbz3MZmimVrW1m9E85sf5H7XLdwcMfxwE8BcJl36F15GIxbDlxeH8/EFxK0eXlfn7+LhY0KVsyexwTLHeEl97/RqIz9SxU1uS2/+tXsX7JzzWPc4/o+EXth9xH5x07m+9GP0uGs54fAwYBRSRuTxVr5QwnXzoGup7CRoLZ68MSnrX4Jt7z3ASZQyWKgU/kZ3+c5k2u91FW4aO4Ks6M1SFOdkZRdrH5IazjCy43Zz8AqFzGH8fMUDRrd02qDWwEYM3meVSEJwaQaHzddsIh1u9uZcf2jHNFUw5UnzAB6hgODMYRYKXJuSGGzGfuswrFEzzwfh3FFc9HypkO9VORBMjEKReOpTmrZDlVNdlpL/zrFru8erEIOkF04qZqFedr3fsLssXSGYihUz0DuEqkiFqOzFo5jen0Fsxt7roFu/shiln3/n9Tl0AxtJJVVglVFF8ts63ktMCn1mEsbFSy3RzbxZ8Pl9vLx6NexKdiUVukAiIeM/Tpxe/72OtWMqSVGz2DoqtrcEqzpYyvZpJ2sTsyiyzuDQvaKHOP3c0fiHBIhuDEc5u7oNTQ7/YzxnjGsr+saPw+2wzz7rqyW5XQ1LOXmmJOPBV7hw0Cbq296ZZTXv1TzAnOjf2X7y500nXkRbd0RWrsjVLjsjPUXrjlIqYg7jZsyiVAH4UiEyfGdoGD8zMMtjkwI6AjG0Nq4IE3e9Y+YSwTjCc1ZP3sWr9POw184jq0t3bgdtqxm/ThSg4Z7EqxSWW42GiSPdcBs0OW0q6zHolSmVReLvbFXkpVNLvLpRx/qOS9EzN8bd4kkucXosHH+fu3Yk10fC5mEH0pZJVh2j5Hp2s2N+wAezARLKlhZcdht2G2KeEITS+heGwuT3RnzmWDZ7DYOKj8NGPuYxtTlsEQQo+PV63oGn45cwxlNCzghb5ENzmZT1Fa4aO6KsGvPbubZttGi/biGeWKrn7WcwCo3YWd2d9aSJ9L3AlXcZ1+JbfyyPiOiDQsr2lhiW8/Tm58BLmLjfqMyM7OhMm9zzUYTbXYL1KFOtjZ38x/Ra1hS1c5XKgu500+I3sKxOBv2dfHyFuM90+9xpi7Kk0vK4gnNlmbj/fpgIMIp//UvaitcvPat0wb9+va0JhqRWG57gMTwJStPya0Ojhz2JPncxrng4uWTmdVYGsu+vS47/3H+AtqDUU6cM5aGqtK/2ReVOVgjIrnsMjbAXtNCK6sEK7nPKtl6GsCtw6DAXSEVrGw12LtJJEJEIlGc3p4NmltqjuWnka9zVONhrMjjvxewV0G8lYNUMsaR24/s/NjbvOu+nNf0LJ7w/CaPUWXnNNfbOO2baNkUZBrQZatiuKu5p82cy6MrfkXjxGlZPb9Kt3OibS2d2su1sSv591mzMz6vcvZK2PZrxrauBiC++i5ecd/Cy7aPAMcNM+rRR7uMCxQd7mRDc5BnE4vwTGwc5FVCjKx97WHO+flzqc/9Xkfqrn/PhZ1CKdAaQrHc9vHY09rApypYcie+YFLJckLzqeOm5VTRqXQ7qHI7iuYOfzZcDhuXrJhidRjDFojEaO2O4HM5SGhjb1kpfR9KwRfueQ3oqRBarbwSLLMTmtNMsGKxOAlsJLTCJXN+svaI/SvU2jto6zyZCm/Phv5Wex3PJxYy15/dhX+2WjxNTO3exs89V/KtHF/bMGk6ThVnNjt52YLN1xfFH+Rw52pe22a8kXbb8zMo+qwzz836uXWd7/Eb1494Pj6fj0WvZ0pd5p/1psNPIv4PxezYBg62H4R97zBWtVNXWfp3DEeCMm/YqEgX6/cZy1hnNUglXFjL3qcJgN/jZElTDWu+dRpup43H1u1NVaEAus1KSLZ305MX9PGE5vDJY9jyg7NSS3PEyJvVWMllR09hSVMN5y/JraHOeYsnct5iacJjhZv+9i6/fXEbXzvD2Kgg1av8m1ZfwaYD3fz0wsVWhwKUWYLl9hkXt+6EkWCF4pqF4TvwuWy8bS+rQzEsUYwmDZFwoNfjgYixJtznyu/a7oi3EbphsrMz59e6a41N1zWqi+N3/hL4SV5jG0zIVQthcLYZs7hCjsIPinaY+wuPta9jRmwXU2oy1xfdlTVsds5gemwjm9c8TVXHBgA8E+cXLNZSEqw5jPtiK4m45jBx/W+5yr6XhVWfsTosUeb6VjT8Xicuhw2Xw9j4/bU/vZFquAPGYE7IfgaWPS3BAhmaWmhLmmoyDovO1sofPUUoGuef15yQms9UzOIJzR9f3cEfXtnBnMZKPrJsMkdOqbU6rJxVeZJzE6N89KimrGeXiewlG/YEzf2JViurrCLZatptdg4MmgmB11lWh2HYIsoFGmLh3sP3Ju97gq85nqcheAGQv65zydlbU2z7cn9x2vp0f6wlXyFlLe6pg05o6F4PQMRV+ATLlTaC4An3tbRXXzTgc1vqlzJ970YC659mangzAGOnZ9/CuZx0TzyWa2M+zvSO49/3fJKPOLeyyXeJ1WGJMtd32ZHf03N+01rTZSZUY3xODgaiqUHZuVSwvn3OPEmqLBaKxlmz/SCVbkdOne72dYQID2HmmVXiCc3X//wmAK/vMFqml2KCVek2ktloXPOfH5CZqyMh2fSrM9R/TqsVSuM3LE88VXU8ED+Wx5VxBz9kZrm5tqktdzFlvlFEQr0en9L6Ip9zPMz40Mb8/oPTVgLg8g9vf0tDlnuW8kn76gFoTBjJYVtt4ZMVl6enM9gBxlBdPfAyxaoFZwJw1O67qaWDLu1lfNOsEY+xFCU7cnV0h4wOgsCEmcWxNEGUr/QK1o3nL+CYGfXsaQ9y6R0vcdXv1xBLaFx2W+qOenKJoCPLBEspxSePm8bHj57KC5uaOftnz/Kfj76T//8RkVFnKMrqba08+e5+Lv6/VVxl7jvJxvaWAOFYae2b61vpsWLQcD5Umr9vyYqxyL9NB4yl+tc/8JbFkRjKqnTj89dwdfTzuLWNS4FY8yaecF3D3lgTcLLV4ZWMmDKWmsT7JFgqZlS0bK78DvQ94uQP8/a0o1g6eYhrxz/7LLxxL5UnfDmvcWXDVjUWgHbt48XEfGaecnnBY0jvkNniGMfYQzx3zjHn8si/TmdH0M2VjofZ4ZzCXFkrnlGVPc4ctZ0Fex7HpWLsVWMZVzXG6rBEmUtWsKrcDi41mwNsbwnw7Ibm1KDZCredUw5rpC0QSbXBdg2hItXWbQxNbaot7BD3crZudwcX3b6KWnPWTy5NLtKbwZZKg4W+cZZqm/Yq84Zca3eY13ccpMJtZ2ZDaXRyLBXFNi6irBIst8OGTRlDEmPxBNHudmbb9oDOX1vxchCzOSEO0UjvJYL2+MgkWEop5k0fRheh8YuM/yzgMhOs1YnZ3DnxRv44uf8MqhGPwdeTYHV5Jx3imaBsNvaf+CP2PmoM4j5YOXNEYytltZHdPOa+LvX5fs80cpvSJkT+Jdt2x9IaTySX83Wby+IrPQ5uONfYW9kZivL7zxzVawjtYB5cu4twLEHyUrdUqiGjQfJY59qcBMDtLL3vU98RISWbYJkVrHf3dnLe/zzP9LEVPHnNidYGNcoU2/tQcUUzwpRSzHUdYKHaTCAUIhI25oBEbdIlLRcxZbRm71vBSra/d7jlbmaSp8a45HYR5WMrmiyJwZuWYMX8h06wAD54xCResS3ihujH2d909kiGVtKa5izmWf/7OYBRtQpPO9XiiIQwbiQ+dNWxXLKiiT++uoP2YLTfRXhFWjJV5XFyzIx6Fk/Ovvp6/QNv8dX730hrkFFWlxKWSt6lTy71y2UvXEOVh8uPmcpXTss8qqNYpedUpbr3rzJVwTJmNRVbtWU0OGOBcb01obo4runLqoIF8Gv1XRrcrexvO5tYyEiwYvbi+GaUigfHXMZ/7zyFT1T1fpNOJVgeKXsnVc9YzozQ3dRUenl+gTX1DafLy6rEPFbY3sZRN/g+tGqvk6OPOpY7np/A+cuOLUCEpclut3P8V36HTiQIBTtZVlH4BiZC9GWzKRZNGsPnfvcau57dwtHT61J3z5OqPA72d4boDMUY5/dQkeMIi+QFb7JblyRYhdP3Ln0ug4aBVOWylNiUIqGNimyp7sE6bJyfX1++jD3tIb7xwJvyOzMCkkuVZxTJuJSyS7BCygMaQoEO4mab8ZhUsHKytWIRTyQaudDRu1WsMxE2/vRKBStpUl0V/3PJcibXelMdbgpOKZzKODlVjpuR1Uu+cdZcPnvCDMZWuQd/cplTNhseSa5EkekwO2lVeRypBhZep52Xrz+FaFxz9b1r+df6A1x35mG0dIWZM87Ph44cvMINPQ0xko2ihrJ/SwxN38pHtu31S5mxT1Bz2Lgqqr3F31o+k2qfk5MOa+DVra1AeXzfCi05OqJY9heWXYIVsXkhDuFAJ3FziRdKMjMAABldSURBVGBCKlg5Sa7jTi5RSGpmDG5dj8Obn2G6o8UZFlWu0n276tvQtp2752ZXkbLZlCRXQpSob/7lzdTyvUq3g7h59z+e0FSZs4/cZiXknT0dPLh2N++b35h1gpW8gEmOOpG78YXTt4JVDsf+3RvPQKn++7FKUSRuXDeVw/et0La2GNf0z6w/YHEkhrJNsKKBThIRo4IVd0iTi1wsDrzELMfLVDTbgQmpx7/q/ibbugI81ZC/GVgiP275+EoOBiLU1pTe/BAhRG5+t2o7YDQEcNht2BKaM+aPw5l2ce42x5Pk2qY9+XUBZjZUcvHyycMafCty40yrRj78heNSifJoZiuSisRwaK25+fH1PPrWXqD4GjKMBmcvHM+9r+zg08dPtzoUoAwTrKjdC1GIhTrZ75nKHbEzqR6znGVWB1ZCFgZeZIXjQV5umQuckXq8Z3CzzBUrNjOLZE2yEKJwfGZbdptNcdulR/LAmp1cfPsqPrBkYurCPFnpymXTfbKCdezMei5abk3znnJV43Pyty8dj8dpZ1p9hdXhFEwklsBuU0Wz/CtXSilue2YzkeQcMqlg5V2D38Pfv7zS6jBSyi7BijuM/UHRUBfbfSv5SczFvzVmty9FGLTdmL+hY727CEqCJYQQxaOyT/OKLQe6eXFzC8un1aYSrO5IshNg9heuyYvc9FbwojAcdhtzx5fXMvyLb1/Fi5tbAHj4quNYOKk097xWuR20xCL8+hPLZHZcGSjbBCsR6iJkN+4kSEKQG+0w96zFwj0PJhK8xKUE3S68zm3WBCaEECLFl5Zg7ToY5M1d7YDR+CJZueoK5b5E8LEvr8SmFHvag7y5s51JNV5qzMG3ojBWb2vlrhe2sWxqDZcePdXqcEbU23s6Uh+Xapt2MObPtXRHmFpXUVbVx3JVdjXKF8ZfxrnhG9lQsxJf52aWqXep1W1Wh1Va7Gbzg7QEKxruxqfCeIn0WucvhBAjQSlVq5R6XCm1wfwz40YgpdRl5nM2KKUuS3v8+0qpHUqprj7Pdyul7lVKbVRKvaSUmjqy/yf5V19pvEff9cnlqcfe//PneOo9Y/N3hduRalbUFU52Asz+fdvjtONy2LjtX5t4/63P8cibe/IVusjC1+5/gwt+8SIPvb6b1dtG//VLrzlYJbpEEHoqyp1mh08xupXdlXCoehpv6Bm0UcURe/7Afe7vMav1KavDKi2O/glWsLsTgBCuUdHpRwhR9K4DntBazwKeMD/vRSlVC3wHOApYDnwnLRF72Hysr08BbVrrmcDNwA9HIPYRlcyVBrowrXQ7+MjSyfz+M0dx6YopTK3zUTeEClS3mZz1XYooRtbDb+xOfZxL5bFUpe+7KtU9WNDze/KFe9bw4NpdFkcjRlrZvStWmJt+A5EYNnMPkc0la2FzkqxgxXsSrHDQuAkcVtLaWwhREOcBJ5of3wU8DXytz3PeBzyutW4FUEo9jtGZ5x6t9SrzsUxf9wbz4/uBW5VSSmtdMhuO5o73M84fwZ72/5beFrrS7WBqfQVT6ys4ZkY9Xzp1Vk5f/2v3v8H6/Z20dkeAnmYaojBcDhuBVIv80k04spX+O5rrYOVikhyRsK0lwOptbZy3eKLFEYmRVLo/qUM0rfsNvu+4gxm7/4o9HgTA5pa1sLlIuP3s12MI0ZNMhQNGghVRMlNMCFEQjVrr5Nq0vUBjhudMBHakfb7TfOxQUq/RWseAdqAu0xOVUlcopV5VSr164EBxzF4BWDlrLKFogiff3Z96LP1CvNIzvHur7+3rZM32g+zrMG5SVkgFq6DSk+VSTjiylV60spdwQjlxTM/1kczBGv3K7l2xIbKdsx1P8HK7G3vcODk4pIKVkx1TL+CS12bzkbGTOcF8LBI0NqGGbDJTTAiRH0qpfwKZJnVfn/6J1lorpQpeYdJa3w7cDrB06dKiqXDtbAvy3r5OuswZV9CzlGxmQyUNVW7W7jjIX1/fzcJJ1TnfSU8uNwxFjUZRUsEqrPT9cqXc9CFbtvRKbAkvEfzueQtorPbwo7+/JwlWGSi7BMvmNuYB2WMBHGaCZXNLgpWLZNfFQDSeeiwaMBKsiE2OpRAiP7TWpw70d0qpfUqp8VrrPUqp8cD+DE/bRc8yQoBJGEsJD2UXMBnYqZRyANVASy5xW63D3ERflVapSl7Q3XLRYqbUVfDK1p386rktAFz/wFtcc/psPnHstKy+ft99MFLBKqz04cLlcKF+7uIJ/H7Vdv7tpJmpZXalKhoz7sO4yiAxLndl967o8JgJVjyIM2EkWE6PLBHMRfJuZTDSc3e01T2JG6OXUFs3mYVWBSaEKCcPAZcBN5l/PpjhOY8B/5nW2OJ04OtZft0XgQ8BT5bS/iuA+1fvBGDXwZ5ZhcklgtG48b+SfpHeFY4Rz2GmVd8ESypYheUyv3dVHkdZzFP6+plz+fqZc60OIy+icaPqWw6JcbkrvwTLWwWAMx5IJVgub6WVIZWchs63edF9FXt3zwQeB6DVOZ474mdxZk2m1TxCCJF3NwF/VEp9CtgGXAiglFoKXKm1/rTWulUpdSPwivma76U1vPgR8FHAp5TaCfxKa30DcAdwt1JqI9AKXFTI/6l8qkhLfL577nzWbD+Iy25Da90rwYKei/ZsJBOsb58zjyOm1NBQJXtvC2nhxGr8Xic/+OBCZoyV65dScd+rO7j1qY0AMs6mDJRdguXyGQmWKx7iWtc36Whv41f1My2OqrS4nQ7Gq1a6462px7rNapbPVXY/UkIIC2itW4BTMjz+KvDptM/vBO7M8LyvAl/N8HgI+HBegy2wSTVedrYFOWHO2NRjc8f7+cD/voDLbmP998/E7exddcqlWUJyD9bUeh+LJ4/JT9Aiaz/+8OFWh1BQG/Z1cvszm5kzropPHDutZFu1p++Xa6iSjsujXdldDbu8fuNPHWRbrJZmXYHXK0sEc+H2GXfM3Ilgz2PNb3Ou7XmmJVYA5fXmL4QQxeTvX17J3vYQMxt6qhudIeMmWLKDYN8KVi7tvo+dWU9thVsqVxYKRePEE0YlcrTPwvrs71az+UA3AJcfMxUozQSr0m3sHzvlsAY+eMQki6MRI210/1Zm4KkawzuJJrboCYTMJg0eWT+eE7e5zNKd6FnfP37PE/zM9T8s7nzaoqiEEEKAMecqPbkCuPvFrQCp2VV9lwTmsifk08dP54Zz53Hnc1v4z0ffGVasInexeIIbHlrH/O88xm9e2Gp1OAVVqtUr6Bk03JnW3VOMXmVXwfLUTuLMyE1UuR38MPFfhJxOvPbTrQ6rpLgrjCqgh54ES0U6jQ9cUg0UQohi86fXdvX6vNLtYGqdj60tASD3TfcdoRh/XrOL8dUevnHW6GhAUCo+9/9e4/G39wFl0iwhrf9KhsHgJSPZ1TNZTRajW9klWKkOeOEQZ3teIqrtOJ2l3faz0LwVRgXLq9MSrKhxklZu2XArhBDFJhyL9/p8dmMVT197Ev98ex+bDnRx2PiqrL/W3vYQr21rA6SDoBXKbQ5WorSaeA4oWcF6Z08Hf31jN+csmmBxRGIklV2C5bTbcNltVMaNhCCEC0mvcuP1eI3EVMWJR8PYnW5sUWN9tF0SLCGEKDphcyhwX6fOa+RUGnP6Wj/6+7v8eY1REZMZWIWXvrzTmUNzklI1OtKrnv2PkFtTGVGayvKdcZXzCmqdxmDcsHKT/X07AWCzKW7VFxCM2fh8JEal0409ZiSsdo8kWEIIUWzCscwJ1lCk74ORClbhSQWrNPnThiT3bTIjRp+y/A532GtSH3fbJCEYirucF/KL+LkEEsbJ1WFWBJNzxoQQQhSPkw9rAOCyo6cA0BmKsvA7jzH1ukd46PXdtHSFs/5a6QlWhYzmKLj0CtZo7yAIkMjfvQFLuRw2jp1ZB5TJ3rkyV5bvjLWf+hNvvvgngge2UjH/TKvDKUlelx26IRgx1vU740bLdqckWEIIUXQa/MbcnWn1RiMil8OW6mb2xXvW8KfPHUNdZXazeXpVsGSJYMH1XiI4+itYv/nEMkLRBDMaSr+JVjRmVONyGYsgSlNZvjP6J8xi4QXXWR1GSVtm28BC2y7C7fOhroJrKn/Ilj0HuGf8EqtDE0II0Ud9pZspdb7UnimXfehzsBxpF/Uzxpb+RW+pSSZYsxoqWVQGg55nNY6eG7cvb20FIBCND/JMUerKMsESw/fpyF3Md63jvQMrYPpUuqLQhQ+fVwZPCiFEsfniKbP44imzUp8rpXA5bETMvVm5LFmymxv0v3n2XD59/PT8BioGdfbC8cxurGT+hGomjvFaHY4YAllaO/rJd1gMSdRmvKlHg0b3wG5zqYm8aQghRGlw90qwcqhgmc+NJ0ZH84FSs2BiNQsmVlsdRsF858G3uOvFbcxsqOSfXznB6nCG5dEvHs87ezpYPq3W6lDECJOrYTEkMbuRYMVCXQD8MvINgk47PsdJVoYlhBAiS26HnU6Mm2O5VLAuXTGFE2ePZXKtb6RCE4N4cO0uDnSGOWfRBMZVj+6VI399Yw8AG/d3WRzJ8M2b4GfeBL/VYYgCkARLDEncYZxYE6EudCzCEvUeMZsN3NltkhZCCGGt9FbRuSRYk2t9/PKZTfxu1XZuPH8Bl66YMhLhiQG8u7eDL/1hLQBLmsaM+gRrtLRpF+VF+kSKIUmYCVY80k2w25gpFsCDwyEzUYQQohRcdfLM1Me5zlMKhI1N+j6nvOcX2prtB1Mfl8PAWlmKKkqRVLDEkCScRoKlw90EuzrwAUHlQQrfQghRGi5e3sT5iycSiSeoyqHd+jPrD/DnNbsAqHBLglVo5TZoWApYohRJgiWGxkywiHQTChgVrJCSbkZCCFFKvC47XnJLkt7c1Z762CeNjQrONcSlnaVKlgiKUjT6fzPFiFg35RKOCN3G0+MuI2wuEQzbJMESQohS8cKmZv60eid720M5vS59DpZUsAovPcFylMGgYVkhKEqR3HoSQ+L0VdOKn66YnWiwE4CIJFhCCFEyfvH0Jp7d0AzAlh+chVLZXazb0y7qpYJVeOlLBMuhgrVsWi3PrD/AGfPHWR2KEFkb1jujUurHwPuBCLAJ+ITW+uChXyVGA5/LuGsZiMTpsI/hvthKdPUMFlgclxBCiOykVz+yTa76vk5mHxZeuS0R/O0nl1sdghA5G+5v5uPAAq31ImA98PXhhyRKwYSuddzlvInTdt9Gs3c618au5In6S6wOSwghRJbsQ1xeZjcv6p12RX2VK58hiSy4HTY8ThvHz6of9S3ahShVw7r1pLX+R9qnq4APDS8cUSoqCbDE/gZvBR28GzHa9Vbk0IVKCCGEtXKpWqWzm6+74IhJskTQAkun1vLujWdaHUbBtHVH2NzcRW2Fm2n1FVaHI0RW8vnO+Eng3oH+Uil1BXAFQFNTUx7/WWEFh8d4k3PFA+jOPcxR2xlrq7Y4KiGEENmyDzHBqq1wMruxkga/VE/EyFty4+Opj7fedLaFkQiRvUETLKXUP4FMOwuv11o/aD7neiAG/L+Bvo7W+nbgdoClS5dKT5gS5/JWAeBMhGjaej+PuW/j+dZPAMdZG5gQQoisDHVG7YlzGtjWEqDGJ8sDrXLqT/+F1pq/fWllrz1Zo9kQ7wcIYYlBEyyt9amH+nul1OXAOcApWsuwgnLh9hkJljsRQkW6jAddUroXQohSYRviFevBQJQf/O1dGqrcXLhscp6jEoPZ2x5i437jvFsObdqThvrzKoQVhttF8Azgq8AJWutAfkISpcBlJlgeHURFu80HKy2MSAghRC6uO/MwYnFNg9+d0+u6IzFA9t1aJX3wrq2sEiyrIxAie8N9d7wVcAOPm5tlV2mtrxx2VKLoeXx+409C2KJGbm33SIIlhBClYlKNj9suPTLn1/1lzS4AtjR35zskkYVyreQMtSmLEFYYbhfBmfkKRJQWX0UVj8ePJKC8TDUrWDa3JFhCCDHaBczOscIa1V6n1SFYQipYopRIfV8Midvl5LOxa0hoeDj2EwAcZuMLIYQQxe/h13fzrQff4v2LJnDj+dmPiZ873j+CUYnBeF12/nH1SjwOu9WhFFS5Vu5EaZIESwyJUgqfy0FXOIY9ZiwRdEmCJYQQJeO5Dc0cDES5e9W2nBKsDyyZiNaaFdPrRjA6cSizG8vnfPuLjx3Bqs0tnD4/U0NrIYqTJFhiyCY5O4hEDnKj+gyRcAffbZxndUhCCCGyNNQ27Xab4sNLpXugKIwzF47nzIXjrQ5DiJyUx/AEMSJ+Ef8uT7r/nZbuGKv1HDyVNVaHJIQQIkvSNEAIIUaGJFhiyCI2DwAVhADwe6QgKoQQpeL8xRMBOFqW+oki9v1H3mbqdY9w65MbrA5FiKxJgiWGLGLzAfCA+zucMzHA2KrcZqkIIYSwzvJptTz71ZP47aeWWx2KEAP6v2e3AHDn81utDUSIHEjJQQzZxPiO1McXr1wgy02EEKLETK71WR2CEFmRNu2ilEgFSwzZ+lgjAM/GF3DMosMsjkYIIYQQo5XcxBWlRBIsMWQbln6XW2IfJHTBXfLGJ4QQQoi8++IpswC45rTZFkciRPZkiaAYso+dczoHTzmJ2gqX1aEIIYQQYhS6+tRZXLpiiuzzFiVFKlhiyGw2JcmVEEIIIUaMUkqSK1FyJMESQgghhBBCiDyRBEsIIYQQQggh8kQSLCGEEEIIIYTIE0mwhBBCCCGEECJPJMESQgghhBBCiDyRBEsIIYQQQggh8kQSLCGEEEIIIYTIE0mwhBBCCCGEECJPJMESQgghhBBCiDyRBEsIIYQQQggh8kQSLCGEEEIIIYTIE0mwhBBCCCGEECJPlNa68P+oUgeAbcP8MvVAcx7CGW3kuGQmx6U/OSaZyXHJLB/HZYrWemw+gik2cl4bUXJc+pNjkpkcl8zkuPSXr2OS8bxmSYKVD0qpV7XWS62Oo9jIcclMjkt/ckwyk+OSmRyXkSfHODM5Lv3JMclMjktmclz6G+ljIksEhRBCCCGEECJPJMESQgghhBBCiDwp5QTrdqsDKFJyXDKT49KfHJPM5LhkJsdl5MkxzkyOS39yTDKT45KZHJf+RvSYlOweLCGEEEIIIYQoNqVcwRJCCCGEEEKIoiIJlhBCCCGEEELkSdEnWEqpM5RS7ymlNiqlrsvw926l1L3m37+klJpa+CgLL4vj8hWl1NtKqTeUUk8opaZYEWchDXZM0p53gVJKK6XKomVpNsdFKXWh+fOyTin1+0LHaIUsfoealFJPKaXWmL9HZ1kRZyEppe5USu1XSr01wN8rpdTPzGP2hlLqiELHOBrIea0/OadlJue1zOS81p+c0/qz9JymtS7a/wA7sAmYDriA14F5fZ7zb8Bt5scXAfdaHXeRHJeTAJ/58edG+3HJ5piYz6sCngFWAUutjrsYjgswC1gD1JifN1gdd5Ecl9uBz5kfzwO2Wh13AY7LSuAI4K0B/v4s4G+AAlYAL1kdc6n9J+e1IR+TsjqnZXtczOfJea3Mz2tyThvwuFh2Tiv2CtZyYKPWerPWOgL8ATivz3POA+4yP74fOEUppQoYoxUGPS5a66e01gHz01XApALHWGjZ/KwA3Aj8EAgVMjgLZXNcPgP8j9a6DUBrvb/AMVohm+OiAb/5cTWwu4DxWUJr/QzQeoinnAf8VhtWAWOUUuMLE92oIee1/uSclpmc1zKT81p/ck7LwMpzWrEnWBOBHWmf7zQfy/gcrXUMaAfqChKddbI5Luk+hZGhj2aDHhOz9DtZa/1IIQOzWDY/K7OB2Uqp55VSq5RSZxQsOutkc1xuAC5RSu0EHgW+UJjQilqu7z2iPzmv9SfntMzkvJaZnNf6k3Pa0IzYOc2Rjy8iipdS6hJgKXCC1bFYSSllA34KXG5xKMXIgbGc4kSMu8LPKKUWaq0PWhqV9S4GfqO1/i+l1NHA3UqpBVrrhNWBCVGu5JzWQ85rhyTntf7knFZAxV7B2gVMTvt8kvlYxucopRwYZc+WgkRnnWyOC0qpU4HrgXO11uECxWaVwY5JFbAAeFoptRVjre1DZbAhOJuflZ3AQ1rrqNZ6C7Ae48Q0mmVzXD4F/BFAa/0i4AHqCxJd8crqvUcckpzX+pNzWmZyXstMzmv9yTltaEbsnFbsCdYrwCyl1DSllAtjs+9DfZ7zEHCZ+fGHgCe1uXNtFBv0uCillgC/xDgRjfa1xzDIMdFat2ut67XWU7XWUzHW8J+rtX7VmnALJpvfob9g3OVDKVWPsbRicyGDtEA2x2U7cAqAUmouxsnoQEGjLD4PAR83Oy+tANq11nusDqrEyHmtPzmnZSbntczkvNafnNOGZsTOaUW9RFBrHVNKXQU8htEh5U6t9Tql1PeAV7XWDwF3YJQ5N2JsZLvIuogLI8vj8mOgErjP3Bu9XWt9rmVBj7Asj0nZyfK4PAacrpR6G4gD12qtR/Pd8myPyzXA/ymlrsbYHHz5KL/IRSl1D8ZFSb25Tv87gBNAa30bxrr9s4CNQAD4hDWRli45r/Un57TM5LyWmZzX+pNzWmZWntPUKD+2QgghhBBCCFEwxb5EUAghhBBCCCFKhiRYQgghhBBCCJEnkmAJIYQQQgghRJ5IgiWEEEIIIYQQeSIJlhBCCCGEEELkiSRYQgghhBBCCJEnkmAJIYQQQgghRJ78f0DGuvv15tXUAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "bFYx-123RtyR"
   },
   "source": [],
   "execution_count": null,
   "outputs": []
  }
 ]
}
